From 89a396a1adc7fbdbbf6b82f1ead02ed7bffa446f Mon Sep 17 00:00:00 2001
From: "(no author)" <(no author)@4701ed2b-b243-491d-98bb-9a9ce286683a>
Date: Fri, 20 Feb 2009 14:16:38 +0000
Subject:

---
 CHANGES                |   57 ++
 ChangeLog              |   84 +++
 Cron.pm                | 1592 ++++++++++++++++++++++++++++++++++++++++++++++++
 MANIFEST               |   15 +
 META.yml               |   11 +
 Makefile.PL            |   12 +
 README                 |  150 +++++
 svn-commit.tmp         |    4 +
 t/callbackreschedule.t |   41 ++
 t/entry.t              |   71 +++
 t/execution_time.t     |  146 +++++
 t/load_crontab.t       |   51 ++
 t/nofork.t             |   99 +++
 t/sighandler.t         |   31 +
 t/startup.t            |   34 ++
 t/test.crontab         |   69 +++
 16 files changed, 2467 insertions(+)
 create mode 100644 CHANGES
 create mode 100644 ChangeLog
 create mode 100644 Cron.pm
 create mode 100644 MANIFEST
 create mode 100644 META.yml
 create mode 100644 Makefile.PL
 create mode 100644 README
 create mode 100644 svn-commit.tmp
 create mode 100644 t/callbackreschedule.t
 create mode 100644 t/entry.t
 create mode 100644 t/execution_time.t
 create mode 100644 t/load_crontab.t
 create mode 100644 t/nofork.t
 create mode 100644 t/sighandler.t
 create mode 100644 t/startup.t
 create mode 100644 t/test.crontab

diff --git a/CHANGES b/CHANGES
new file mode 100644
index 0000000..64ceb41
--- /dev/null
+++ b/CHANGES
@@ -0,0 +1,57 @@
+0.97
+
+- Use POSIX only where available, otherwise fallback to an emulation of waipid.
+- Fixed bug when previous SIGCHLD handler was not a coderef, but a String value like 
+  "DEFAULT" or "IGNORE"
+- Added tests
+- Made test more robust so they work now also on system without alarm() functionality 
+  (Win32)
+
+0.96 
+
+- Applied patch for #4917 in order to be smarter to existing SIGCHLD handler and to 
+  reap only own childs.
+
+
+0.95 
+
+- If a scheduled method in 'nofork' manipulates the execution queue with 
+  add_entry or delete_entry, it will be picked up during the next run. 
+
+- Clarified different behaviour of global variables within the fork/norfork 
+  mode in the documentation
+
+- Fixed warning about non-numeric arguments when sorting. 
+
+- Fixed bug which called to an undefined methods in a die-message
+
+- Pretty print a hashref in $0 if provided as argument and the 
+  prefix for the name to be shown in the process list can be configured
+  with the option "processprefix"
+
+0.9
+
+- Logging: It is now possible to add a reference to a custom logging
+  subroutine to the constructor which will be used for logging certain
+  events.
+- NoFork: The option 'nofork' prevents Cron.pm from creating a new
+  child process. Instead, the job is run within the current
+  process. You can use the 'skip' and 'catch' options to tune the
+  behaviour.
+- Seconds granularity: Cron times can now be specified up to the
+  second. 
+- Bugfix: Thinks like "*/5" now work like expected
+
+0.05   
+
+- Other bugfixes for parsedate problem with single digit hours/minutes 
+  and warnings if argumentlist of command to execute is empty
+
+0.03
+
+- Minor bug fixes (reaping of child processes improved, 
+  fixed regexp in get_next_execution_time())
+
+0.01
+
+- Initial Release
diff --git a/ChangeLog b/ChangeLog
new file mode 100644
index 0000000..0cfc50c
--- /dev/null
+++ b/ChangeLog
@@ -0,0 +1,84 @@
+2006-11-27  Roland Huss  <roland@consol.de>
+
+	* Cron.pm (REAPER): Added support for plattforms where POSIX is
+	not available.
+	(run): Call previous childhandler only if it is a coderef
+
+2006-11-08  Roland Huss  <roland@consol.de>
+
+	* Cron.pm (run): Removed leading space when no process prefix is
+	used (for backwards compatibility)
+
+2006-11-05  Roland Huss  <roland@consol.de>
+
+	* CHANGES: added long forgotten patch for child process handling
+
+2006-11-05  Roland Huss  <roland@cpan.org>
+
+	* CHANGES: added patches and suggestions from
+	  - Andrew Danforth
+	  - Frank Mayer
+	  - Jamie McCarthy
+	  - Andy Ford
+
+	  Thanks !
+	
+2006-11-04  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm: Worked on:
+	  - Reexamination of crontabs entry in 'nofork' mode if someone
+	    has added a new entry
+
+2004-01-30  Roland Huss  <roland@cpan.org>
+
+	* t/entry.t (Module): added and extended tests
+
+2004-01-29  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm (add_entry): added heuristic for parsing crontab with 6
+	time columns
+
+2004-01-28  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm (new): added new options 'nofork', 'skip', 'catch' and
+	'log'
+	(get_next_execution_time): allow a sixth column for specifing the
+	second to start up
+
+2002-08-09  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm (get_next_execution_time): added recognition of "*/5"
+	notations (thanks to Loic Paillotin for spotting this problem)
+
+2002-04-02  Roland Huss  <roland@cpan.org>
+
+	* Released 0.0.5
+
+2000-07-05  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm: added patch from Lars Holokowo for working around a bug
+	in parsedate, which has trouble in parsing times in the form "3:1
+	2000/6/30". Added tests to check for those dates 
+
+2000-06-14  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm: added additional check for arguments to avoid warnings
+	as suggested by  David Parker
+
+	* Makefile.PL: added check for Time::ParseDate as suggested by
+	Philippe Verdret
+
+2000-06-12  Roland Huss  <roland@cpan.org>
+
+	* Cron.pm: Fixed bug in regexp splitting the crontab entry in
+	get_next_execution_time() report by Peter Vary
+
+2000-03-23  Roland Huss  <roland@cpan.org>
+	* Cron.pm: fixed problem when reaping childs: Now SIGCHLD handler
+	can handle more than one finished child at once (thanx to Bray
+	Jones for discovering this bug)
+	
+2000-01-02  Roland Huss  <roland@cpan.org>
+
+	* Initial release 0.001 
+
diff --git a/Cron.pm b/Cron.pm
new file mode 100644
index 0000000..21ae607
--- /dev/null
+++ b/Cron.pm
@@ -0,0 +1,1592 @@
+#!/usr/bin/perl -w
+
+# $Id: Cron.pm,v 1.16 2006/11/27 13:42:52 roland Exp $
+
+=head1 NAME
+
+Cron - cron-like scheduler for Perl subroutines
+
+=head1 SYNOPSIS
+
+  use Schedule::Cron;
+
+  # Subroutines to be called
+  sub dispatcher { 
+    print "ID:   ",shift,"\n"; 
+    print "Args: ","@_","\n";
+  }
+
+  sub check_links { 
+    # do something... 
+  }
+
+  # Create new object with default dispatcher
+  my $cron = new Schedule::Cron(\&dispatcher);
+
+  # Load a crontab file
+  $cron->load_crontab("/var/spool/cron/perl");
+
+  # Add dynamically  crontab entries
+  $cron->add_entry("3 4  * * *",ROTATE => "apache","sendmail");
+  $cron->add_entry("0 11 * * Mon-Fri",\&check_links);
+
+  # Run scheduler 
+  $cron->run(detach=>1);
+                   
+
+=head1 DESCRIPTION
+
+This module provides a simple but complete cron like scheduler.  I.e this
+modules can be used for periodically executing Perl subroutines.  The dates and
+parameters for the subroutines to be called are specified with a format known
+as crontab entry (L<"METHODS">, C<add_entry()> and L<crontab(5)>)
+
+The philosophy behind C<Schedule::Cron> is to call subroutines periodically
+from within one single Perl program instead of letting C<cron> trigger several
+(possibly different) perl scripts. Everything under one roof.  Furthermore
+C<Schedule::Cron> provides mechanism to create crontab entries dynamically,
+which isn't that easy with C<cron>.
+
+C<Schedule::Cron> knows about all extensions (well, at least all extensions I'm
+aware of, i.e those of the so called "Vixie" cron) for crontab entries like
+ranges including 'steps', specification of month and days of the week by name
+or coexistence of lists and ranges in the same field.  And even a bit more
+(like lists and ranges with symbolic names).
+
+=head1 METHODS
+
+=over 4
+
+=cut
+
+#'
+
+package Schedule::Cron;
+
+use Time::ParseDate;
+use Data::Dumper;
+
+use strict;
+use vars qw($VERSION  $DEBUG);
+use subs qw(dbg);
+
+my $HAS_POSIX;
+
+BEGIN {
+  eval { 
+    require POSIX;
+    import POSIX ":sys_wait_h";
+  };
+  $HAS_POSIX = $@ ? 0 : 1;
+}
+
+
+$VERSION = 0.97;
+
+our $DEBUG = 0;
+my %STARTEDCHILD = ();
+
+my @WDAYS = qw(
+                 Sunday
+                 Monday
+                 Tuesday
+                 Wednesday
+                 Thursday
+                 Friday
+                 Saturday
+                 Sunday
+                );
+
+my @ALPHACONV = (
+                 { },
+                 { },
+                 { },
+                 { qw(jan 1 feb 2 mar 3 apr 4 may 5 jun 6 jul 7 aug 8
+                      sep 9 oct 10 nov 11 dec 12) },
+                 { qw(sun 0 mon 1 tue 2 wed 3 thu 4 fri 5 sat 6)},
+                 {  }
+                );
+my @RANGES = ( 
+              [ 0,59 ],
+              [ 0,23 ],
+              [ 0,31 ],
+              [ 0,12 ],
+              [ 0,7  ],
+              [ 0,60 ]
+             );
+
+my @LOWMAP = ( 
+              {},
+              {},
+              { 0 => 1},
+              { 0 => 1},
+              { 7 => 0},
+              {},
+             );
+
+sub REAPER {
+    if ($HAS_POSIX)
+    {
+        # Only on platforms supporting POSIX semantisc
+        foreach my $pid (keys %STARTEDCHILD) {
+            my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
+            if ($res > 0) {
+                # We reaped a truly running process
+                delete $STARTEDCHILD{$pid};
+            }
+        }
+    } 
+    else
+    {
+        my $waitedpid = 0;
+        while($waitedpid != -1) {
+            $waitedpid = wait;
+        }
+    }
+}
+
+=item $cron = new Schedule::Cron($dispatcher,[extra args])
+
+Creates a new C<Cron> object.  C<$dispatcher> is a reference to a subroutine,
+which will be called by default.  C<$dispatcher> will be invoked with the
+arguments parameter provided in the crontab entry if no other subroutine is
+specified. This can be either a single argument containing the argument
+parameter literally has string (default behavior) or a list of arguments when
+using the C<eval> option described below.
+
+The date specifications must be either provided via a crontab like file or
+added explicitly with C<add_entry()> (L<"add_entry">).
+
+I<extra_args> can be a hash or hash reference for additional arguments.  The
+following parameters are recognized:
+
+=over
+
+=item file => <crontab>  
+
+
+Load the crontab entries from <crontab>
+
+=item eval =>  1
+
+Eval the argument parameter in a crontab entry before calling the subroutine
+(instead of literally calling the dispatcher with the argument parameter as
+string)
+
+=item nofork => 1
+
+Don't fork when starting the scheduler. Instead, the jobs are executed within
+current process. In your executed jobs, you have full access to the global
+variables of your script and hence might influence other jobs running at a
+different time. This behaviour is fundamentally different to the 'fork' mode,
+where each jobs gets its own process and hence a B<copy> of the process space,
+independent of each other job and the main process. This is due to the nature
+of the  C<fork> system call. 
+
+=item skip => 1
+
+Skip any pending jobs whose time has passed. This option is only useful in
+combination with C<nofork> where a job might block the execution of the
+following jobs for quite some time. By default, any pending job is executed
+even if its scheduled execution time has already passed. With this option set
+to true all pending which would have been started in the meantime are skipped. 
+
+=item catch => 1
+
+Catch any exception raised by a job. This is especially useful in combination with
+the C<nofork> option to avoid stopping the main process when a job raises an
+exception (dies).
+
+=item log => \&log_sub
+
+Install a logging subroutine. The given subroutine is called for several events
+during the lifetime of a job. This method is called with two arguments: A log
+level of 0 (info),1 (warning) or 2 (error) depending on the importance of the
+message and the message itself.
+
+For example, you could use I<Log4Perl> (L<http://log4perl.sf.net>) for logging
+purposes for example like in the following code snippet:
+
+   use Log::Log4perl;
+   use Log::Log4perl::Level;
+
+   my $log_method = sub {
+      my ($level,$msg) = @_;
+      my $DBG_MAP = { 0 => $INFO, 1 => $WARN, 2 => $ERROR };
+
+      my $logger = Log::Log4Perl->get_logger("My::Package");
+      $logger->log($DBG_MAP->{$level},$msg);
+   }
+  
+   my $cron = new Schedule::Cron(.... , log => $log_method);
+
+=item processprefix => <name>
+
+Cron::Schedule sets the process' name (i.e. C<$0>) to contain some informative
+messages like when the next job executes or with which arguments a job is
+called. By default, the prefix for this labels is C<Schedule::Cron>. With this
+option you can set it to something different. You can e.g. use C<$0> to include
+the original process name.
+
+=back
+
+=cut
+
+sub new 
+{
+    my $class = shift;
+    my $dispatcher = shift || die "No dispatching sub provided";
+    die "Dispatcher not a ref to a subroutine" unless ref($dispatcher) eq "CODE";
+    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
+    $cfg->{processprefix} = "Schedule::Cron" unless $cfg->{processprefix};
+    my $self = { 
+                cfg => $cfg,
+                dispatcher => $dispatcher,
+                queue => [ ],
+                map => { }
+             };
+    bless $self,(ref($class) || $class);
+    
+    $self->load_crontab if $cfg->{file};
+    $self;
+}
+
+=item $cron->load_crontab($file)
+
+=item $cron->load_crontab(file=>$file,[eval=>1])
+
+Loads and parses the crontab file C<$file>. The entries found in this file will
+be B<added> to the current time table with C<$cron-E<gt>add_entry>.
+
+The format of the file consists of cron commands containing of lines with at
+least 5 columns, whereas the first 5 columns specify the date.  The rest of the
+line (i.e columns 6 and greater) contains the argument with which the
+dispatcher subroutine will be called.  By default, the dispatcher will be
+called with one single string argument containing the rest of the line
+literally.  Alternatively, if you call this method with the optional argument
+C<eval=E<gt>1> (you must then use the second format shown above), the rest of
+the line will be evaled before used as argument for the dispatcher.
+
+For the format of the first 5 columns, please see L<"add_entry">.
+
+Blank lines and lines starting with a C<#> will be ignored. 
+
+There's no way to specify another subroutine within the crontab file.  All
+calls will be made to the dispatcher provided at construction time.
+
+If    you   want    to    start   up    fresh,    you   should    call
+C<$cron-E<gt>clean_timetable()> before.
+
+Example of a crontab fiqw(le:)
+
+   # The following line runs on every Monday at 2:34 am
+   34 2 * * Mon  "make_stats"
+   # The next line should be best read in with an eval=>1 argument
+   *  * 1 1 *    { NEW_YEAR => '1',HEADACHE => 'on' }
+
+=cut
+
+#'
+
+sub load_crontab 
+{
+  my $self = shift;
+  my $cfg = shift;
+
+  if ($cfg) 
+  {
+      if (@_) 
+      {
+          $cfg = ref($cfg) eq "HASH" ? $cfg : { $cfg,@_ };
+      } 
+      elsif (!ref($cfg)) 
+      {
+          my $new_cfg = { };
+          $new_cfg->{file} = $cfg;
+          $cfg = $new_cfg;
+      }
+  }
+  
+  my $file = $cfg->{file} || $self->{cfg}->{file} || die "No filename provided";
+  my $eval = $cfg->{eval} || $self->{cfg}->{eval};
+  
+  open(F,$file) || die "Cannot open schedule $file : $!";
+  my $line = 0;
+  while (<F>) 
+  {
+      $line++;
+      next if /^$/;
+      next if /^\s*#/;
+      chomp;
+      s/\s*(.*)\s*$/$1/;
+      my ($min,$hour,$dmon,$month,$dweek,$rest) = split (/\s+/,$_,6);
+      
+      my $time = [ $min,$hour,$dmon,$month,$dweek ];
+
+      # Try to check, whether an optional 6th column specifying seconds 
+      # exists: 
+      my $args;
+      if ($rest)
+      {
+          my ($col6,$more_args) = split(/\s+/,$rest,2);
+          if ($col6 =~ /^[\d\-\*\,\/]+$/)
+          {
+              push @$time,$col6;
+              dbg "M: $more_args";
+              $args = $more_args;
+          }
+          else
+          {
+              $args = $rest;
+          }
+      }
+      $self->add_entry($time,{ 'args' => $args, 'eval' => $eval});
+  }
+  close F;
+}
+
+=item $cron->add_entry($timespec,[arguments])
+
+Adds a new entry to the list of scheduled cron jobs.
+
+B<Time and Date specification>
+
+C<$timespec> is the specification of the scheduled time in crontab format
+(L<crontab(5)>) which contains five mandatory time and date fields and an
+optional 6th column. C<$timespec> can be either a plain string, which contains
+a whitespace separated time and date specification.  Alternatively,
+C<$timespec> can be a reference to an array containing the five elements for
+the date fields.
+
+The time and date fields are (taken mostly from L<crontab(5)>, "Vixie" cron): 
+
+   field          values
+   =====          ======
+   minute         0-59
+   hour           0-23
+   day of month   1-31 
+   month          1-12 (or as names)
+   day of week    0-7 (0 or 7 is Sunday, or as names )
+   seconds        0-59 (optional)
+
+ A field may be an asterisk (*), which always stands for
+ ``first-last''.
+
+ Ranges of numbers are  allowed.  Ranges are two numbers
+ separated  with  a  hyphen.   The  specified  range  is
+ inclusive.   For example, 8-11  for an  ``hours'' entry
+ specifies execution at hours 8, 9, 10 and 11.
+
+ Lists  are allowed.   A list  is a  set of  numbers (or
+ ranges)  separated by  commas.   Examples: ``1,2,5,9'',
+ ``0-4,8-12''.
+
+ Step  values can  be used  in conjunction  with ranges.
+ Following a range with ``/<number>'' specifies skips of
+ the  numbers value  through the  range.   For example,
+ ``0-23/2'' can  be used in  the hours field  to specify
+ command execution every  other hour (the alternative in
+ the V7 standard is ``0,2,4,6,8,10,12,14,16,18,20,22'').
+ Steps are  also permitted after an asterisk,  so if you
+ want to say ``every two hours'', just use ``*/2''.
+
+ Names can also  be used for the ``month''  and ``day of
+ week''  fields.  Use  the  first three  letters of  the
+ particular day or month (case doesn't matter).
+
+ Note: The day of a command's execution can be specified
+       by two fields  -- day of month, and  day of week.
+       If both fields are restricted (ie, aren't *), the
+       command will be run when either field matches the
+       current  time.  For  example, ``30  4 1,15  * 5''
+       would cause a command to be run at 4:30 am on the
+       1st and 15th of each month, plus every Friday
+
+Examples:
+
+ "8  0 * * *"         ==> 8 minutes after midnight, every day
+ "5 11 * * Sat,Sun"   ==> at 11:05 on each Saturday and Sunday
+ "0-59/5 * * * *"     ==> every five minutes
+ "42 12 3 Feb Sat"    ==> at 12:42 on 3rd of February and on 
+                          each Saturday in February
+ "32 11 * * * 0-30/2" ==> 11:32:00, 11:32:02, ... 11:32:30 every 
+                          day
+
+In addition, ranges or lists of names are allowed. 
+
+An optional sixth column can be used to specify the seconds within the
+minute. If not present, it is implicitely set to "0".
+
+B<Command specification>
+
+The subroutine to be executed when the the C<$timespec> matches can be
+specified in several ways.
+
+First, if the optional C<arguments> are lacking, the default dispatching
+subroutine provided at construction time will be called without arguments.
+
+If the second parameter to this method is a reference to a subroutine, this
+subroutine will be used instead of the dispatcher.
+
+Any additional parameters will be given as arguments to the subroutine to be
+executed.  You can also specify a reference to an array instead of a list of
+parameters.
+
+You can also use a named parameter list provided as an hashref.  The named
+parameters recognized are:
+
+=over
+
+=item subroutine      
+
+=item sub 
+
+Reference to subroutine to be executed
+
+=item arguments
+
+=item args
+
+Reference to array containing arguments to be use when calling the subroutine
+
+=item eval
+
+If true, use the evaled string provided with the C<arguments> parameter.  The
+evaluation will take place immediately (not when the subroutine is going to be
+called)
+
+=back
+
+Examples:
+
+   $cron->add_entry("* * * * *");
+   $cron->add_entry("* * * * *","doit");
+   $cron->add_entry("* * * * *",\&dispatch,"first",2,"third");
+   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
+                                 'arguments'  => [ "first",2,"third" ]});
+   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
+                                 'arguments'  => '[ "first",2,"third" ]',
+                                 'eval'       => 1});
+
+=cut 
+
+sub add_entry 
+{ 
+    my $self = shift;
+    my $time = shift;
+    my $args = shift || []; 
+    my $dispatch;
+    
+    #  dbg "Args: ",Dumper($time,$args);
+    
+    if (ref($args) eq "HASH") 
+    {
+        my $cfg = $args;
+        $args = undef;
+        $dispatch = $cfg->{subroutine} || $cfg->{sub};
+        $args = $cfg->{arguments} || $cfg->{args} || [];
+        if ($cfg->{eval} && $cfg) 
+        {
+            die "You have to provide a simple scalar if using eval" if (ref($args));
+            my $orig_args = $args;
+            dbg "Evaled args ",Dumper($args);
+            $args = [ eval $args ];
+            die "Cannot evaluate args (\"$orig_args\")"
+              if $@;
+        }
+    } 
+    elsif (ref($args) eq "CODE") 
+    {
+        $dispatch = $args;
+        $args = shift || [];
+    }
+    if (ref($args) ne "ARRAY") 
+    {
+        $args = [ $args,@_ ];
+    }
+
+    $dispatch ||= $self->{dispatcher};
+
+
+    my $time_array = ref($time) ? $time : [ split(/\s+/,$time) ];
+    die "Invalid number of columns in time entry (5 or 6)\n"
+      if ($#$time_array != 4 && $#$time_array !=5);
+    $time = join ' ',@$time_array;
+
+    #  dbg "Adding ",Dumper($time);
+    push @{$self->{time_table}},
+    {
+     time => $time,
+     dispatcher => $dispatch,
+     args => $args
+    };
+    
+    $self->{entries_changed} = 1;
+    #  dbg "Added Args ",Dumper($self->{args});
+    
+    my $index = $#{$self->{time_table}};
+    my $id = $args->[0];
+    $self->{map}->{$id} = $index if $id;
+    
+    return $#{$self->{time_table}};
+}
+
+=item @entries = $cron->list_entries()
+
+Return a list of cron entries. Each entry is a hash reference of the following
+form:
+
+  $entry = { 
+             time => $timespec,
+             dispatch => $dispatcher,
+             args => $args_ref
+           }
+
+Here C<$timespec> is the specified time in crontab format as provided to
+C<add_entry>, C<$dispatcher> is a reference to the dispatcher for this entry
+and C<$args_ref> is a reference to an array holding additional arguments (which
+can be an empty array reference). For further explanation of this arguments
+refer to the documentation of the method C<add_entry>.
+
+The order index of each entry can be used within C<update_entry>, C<get_entry>
+and C<delete_entry>. But be aware, when you are deleting an entry, that you
+have to refetch the list, since the order will have changed.
+
+Note that these entries are returned by value and were opbtained from the
+internal list by a deep copy. I.e. you are free to modify it, but this won't
+influence the original entries. Instead use C<update_entry> if you need to
+modify an exisiting crontab entry.
+
+=cut
+
+sub list_entries
+{
+    my ($self) = shift;
+    
+    my @ret;
+    foreach my $entry (@{$self->{time_table}})
+    {
+        # Deep copy $entry
+        push @ret,$self->deep_copy_entry($entry);
+    }
+    return @ret;
+}
+
+
+=item $entry = $cron->get_entry($idx)
+
+Get a single entry. C<$entry> is either a hashref with the possible keys
+C<time>, C<dispatch> and C<args> (see C<list_entries()>) or undef if no entry
+with the given index C<$idx> exists.
+
+=cut
+
+sub get_entry
+{
+    my ($self,$idx) = @_;
+
+    my $entry = $self->{time_table}->[$idx];
+    if ($entry)
+    {
+        return $self->deep_copy_entry($entry);
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->delete_entry($idx)
+
+Delete the entry at index C<$idx>. Returns the deleted entry on success,
+C<undef> otherwise.
+
+=cut
+
+sub delete_entry
+{
+    my ($self,$idx) = @_;
+
+    if ($idx <= $#{$self->{time_table}})
+    {
+        $self->{entries_changed} = 1;
+        return splice @{$self->{time_table}},$idx,1;
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->update_entry($idx,$entry)
+
+Updates the entry with index C<$idx>. C<$entry> is a hash ref as descibed in
+C<list_entries()> and must contain at least a value C<$entry->{time}>. If no
+C<$entry->{dispatcher}> is given, then the default dispatcher is used.  This
+method returns the old entry on success, C<undef> otherwise.
+
+=cut 
+
+sub update_entry
+{
+    my ($self,$idx,$entry) = @_;
+
+    die "No update entry given" unless $entry;
+    die "No time specification given" unless $entry->{time};
+    
+    if ($idx <= $#{$self->{time_table}})
+    {
+        my $new_entry = $self->deep_copy_entry($entry);
+        $new_entry->{dispatcher} = $self->{dispatcher} 
+          unless $new_entry->{dispatcher};
+        $new_entry->{args} = []
+          unless $new_entry->{args};
+        return splice @{$self->{time_table}},$idx,1,$new_entry;
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->run([options])
+
+This method starts the scheduler.
+
+When called without options, this method will never return and executes the
+scheduled subroutine calls as needed.
+
+Alternatively, you can detach the main scheduler loop from the current process
+(daemon mode). In this case, the pid of the forked scheduler process will be
+returned.
+
+The C<options> parameter specifies the running mode of C<Schedule::Cron>.  It
+can be either a plain list which will be interpreted as a hash or it can be a
+reference to a hash. The following named parameters (keys of the provided hash)
+are recognized:
+
+=over
+
+=item   detach    
+
+If set to a true value the scheduler process is detached from the current
+process (UNIX only).
+
+=item  pid_file  
+
+If running in daemon mode, name the optional file, in which the process id of
+the scheduler process should be written. By default, no PID File will be
+created.
+
+=item nofork, skip, catch, log
+
+See C<new()> for a description of these configuration parameters, which can be
+provided here as well. Note, that the options given here overrides those of the
+constructor.
+
+=back
+
+
+Examples:
+
+   # Start  scheduler, detach  from current  process and
+   # write  the  PID  of  the forked  scheduler  to  the
+   # specified file
+   $cron->run(detach=>1,pid_file=>"/var/run/scheduler.pid");
+
+   # Start scheduler and wait forever.
+   $cron->run();
+
+=cut
+
+sub run 
+{ 
+    my $self = shift;
+    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
+    $cfg = { %{$self->{cfg}}, %$cfg }; # Merge in global config;
+
+    my $log = $cfg->{log};
+
+    $self->build_initial_queue;
+    delete $self->{entries_changed};
+    die "Nothing in schedule queue" unless @{$self->{queue}};
+    
+    # Install reaper now.
+    my $old_child_handler = $SIG{'CHLD'};
+    $SIG{'CHLD'} = sub {
+        &REAPER();
+        if ($old_child_handler && ref $old_child_handler eq 'CODE')
+        {
+            &$old_child_handler();
+        }
+    };
+
+    my $mainloop = sub 
+    {
+        while (42) 
+        {
+            my ($index,$time) = @{shift @{$self->{queue}}};
+            my $now = time;
+            my $sleep = 0;
+            if ($time < $now)
+            {
+                if ($cfg->{skip})
+                {
+                    $log->(0,"Schedule::Cron - Skipping job $index")
+                      if $log;
+                    $self->update_queue($index);
+                    next;
+                }
+            }
+            else
+            {
+                $sleep = $time - $now;
+            }
+            $0 = $self->get_process_prefix()." MainLoop - next: ".scalar(localtime($time));
+            die "No time found\n" unless $time;
+
+            dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")";
+            while ($sleep > 0) 
+            {
+                sleep($sleep);
+                $sleep = $time - time;
+            }
+
+            $self->execute($index,$cfg);
+
+            if ($self->{entries_changed}) {
+               dbg "rebuilding queue";
+               $self->build_initial_queue;
+               delete $self->{entries_changed};
+            } else {
+               $self->update_queue($index);
+            }
+        } 
+    };
+
+    if ($cfg->{detach}) 
+    {
+        defined(my $pid = fork) or die "Can't fork: $!";
+        if ($pid) 
+        {
+            # Parent:
+            if ($cfg->{pid_file}) 
+            {
+                if (open(P,">".$cfg->{pid_file})) 
+                {
+                    print P $pid,"\n";
+                    close P;
+                } 
+                else 
+                {
+                    warn "Warning: Cannot open ",$cfg->{pid_file}," : $!\n";
+                }
+                
+            }
+            return $pid;
+        } 
+        else 
+        {
+            # Child:
+            # Try to detach from terminal:
+            chdir '/';
+            open STDIN, '/dev/null' or die "Can't read /dev/null: $!";
+            open STDOUT, '>/dev/null' or die "Can't write to /dev/null: $!";
+            
+            eval { require POSIX; };
+            if ($@) 
+            {
+                #      if (1) {
+                if (open(T,"/dev/tty")) 
+                {
+                    dbg "No setsid found, trying ioctl() (Error: $@)";
+                    eval { require 'ioctl.ph'; };
+                    if ($@) 
+                    {
+                        eval { require 'sys/ioctl.ph'; };
+                        if ($@) 
+                        {
+                            die "No 'ioctl.ph'. Probably you have to run h2ph (Error: $@)";
+                        }
+                    }
+                    my $notty = &TIOCNOTTY;
+                    die "No TIOCNOTTY !" if $@ || !$notty;
+                    ioctl(T,$notty,0) || die "Cannot issue ioctl(..,TIOCNOTTY) : $!";
+                    close(T);
+                };
+            } 
+            else 
+            {
+                &POSIX::setsid() || die "Can't start a new session: $!";
+            }
+            open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
+            
+            $0 = $self->get_process_prefix()." MainLoop";
+            &$mainloop();
+        }
+    } 
+    else 
+    {
+        &$mainloop(); 
+    }
+}
+
+
+=item $cron->clean_timetable()
+
+Remove all scheduled entries
+
+=cut
+
+sub clean_timetable 
+{ 
+    my $self = shift;
+    $self->{entries_changed} = 1;
+    $self->{time_table} = [];
+}
+
+
+=item $cron->check_entry($id)
+
+Check, whether the given ID is already registered in the timetable. 
+A ID is the first argument in the argument parameter of the 
+a crontab entry.
+
+Returns (one of) the index in the  timetable (can be 0, too) if the ID
+could be found or C<undef> otherwise.
+
+Example:
+
+   $cron->add_entry("* * * * *","ROTATE");
+   .
+   .
+   defined($cron->check_entry("ROTATE")) || die "No ROTATE entry !"
+
+=cut 
+
+sub check_entry 
+{ 
+    my $self = shift;
+    my $id = shift;
+    return $self->{map}->{$id};
+}
+
+
+=item $cron->get_next_execution_time($cron_entry,[$ref_time])
+
+Well, this is mostly an internal method, but it might be useful on 
+its own. 
+
+The purpose of this method is to calculate the next execution time
+from a specified crontab entry
+
+Parameters:
+
+=over
+
+=item $cron_entry  
+
+The crontab entry as specified in L<"add_entry">
+
+=item $ref_time    
+
+The reference time for which the next time should be searched which matches
+C<$cron_entry>. By default, take the current time
+
+=back
+
+This method returns the number of epoch-seconds of the next matched 
+date for C<$cron_entry>.
+
+Since I suspect, that this calculation of the next execution time might
+fail in some circumstances (bugs are lurking everywhere ;-) an
+additional interactive method C<bug()> is provided for checking
+crontab entries against your expected output. Refer to the
+top-level README for additional usage information for this method.
+
+=cut
+
+sub get_next_execution_time 
+{ 
+  my $self = shift;
+  my $cron_entry = shift;
+  my $time = shift;
+  
+  $cron_entry = [ split /\s+/,$cron_entry ] unless ref($cron_entry);
+
+  # Expand and check entry:
+  # =======================
+  die "Exactly 5 or 6 columns has to be specified for a crontab entry ! (not ",
+    scalar(@$cron_entry),")"
+      if ($#$cron_entry != 4 && $#$cron_entry != 5);
+  
+  my @expanded;
+  my $w;
+  
+  for my $i (0..$#$cron_entry) 
+  {
+      my @e = split /,/,$cron_entry->[$i];
+      my @res;
+      my $t;
+      while (defined($t = shift @e)) {
+          # Subst "*/5" -> "0-59/5"
+          $t =~ s|^\*(/.+)$|$RANGES[$i][0]."-".$RANGES[$i][1].$1|e; 
+          
+          if ($t =~ m|^([^-]+)-([^-/]+)(/(.*))?$|) 
+          {
+              my ($low,$high,$step) = ($1,$2,$4);
+              $step = 1 unless $step;
+              if ($low !~ /^(\d+)/) 
+              {
+                  $low = $ALPHACONV[$i]{lc $low};
+              }
+              if ($high !~ /^(\d+)/) 
+              {
+                  $high = $ALPHACONV[$i]{lc $high};
+              }
+              if (! defined($low) || !defined($high) ||  $low > $high || $step !~ /^\d+$/) 
+              {
+                  die "Invalid cronentry '",$cron_entry->[$i],"'";
+              }
+              my $j;
+              for ($j = $low; $j <= $high; $j += $step) 
+              {
+                  push @e,$j;
+              }
+          } 
+          else 
+          {
+              $t = $ALPHACONV[$i]{lc $t} if $t !~ /^(\d+|\*)$/;
+              $t = $LOWMAP[$i]{$t} if exists($LOWMAP[$i]{$t});
+              
+              die "Invalid cronentry '",$cron_entry->[$i],"'" 
+                if (!defined($t) || ($t ne '*' && ($t < $RANGES[$i][0] || $t > $RANGES[$i][1])));
+              push @res,$t;
+          }
+      }
+      push @expanded, ($#res == 0 && $res[0] eq '*') ? [@res] : [ sort { $a <=> $b} @res];
+  }
+  
+  # Calculating time:
+  # =================
+  my $now = $time || time;
+
+  if ($expanded[2]->[0] ne '*' && $expanded[4]->[0] ne '*') 
+  {
+      # Special check for which time is lower (Month-day or Week-day spec):
+      my @bak = @{$expanded[4]};
+      $expanded[4] = [ '*' ];
+      my $t1 = $self->calc_time($now,\@expanded);
+      $expanded[4] = \@bak;
+      $expanded[2] = [ '*' ];
+      my $t2 = $self->calc_time($now,\@expanded);
+      dbg "MDay : ",scalar(localtime($t1))," -- WDay : ",scalar(localtime($t2));
+      return $t1 < $t2 ? $t1 : $t2;
+  } 
+  else 
+  {
+      # No conflicts possible:
+      return $self->calc_time($now,\@expanded);
+  }
+}
+
+# ==================================================
+# PRIVATE METHODS:
+# ==================================================
+
+# Build up executing queue and delete any
+# existing entries
+sub build_initial_queue 
+{ 
+    my $self = shift;
+    $self->{queue} = [ ];
+    #  dbg "TT: ",$#{$self->{time_table}};
+    for my $id (0..$#{$self->{time_table}}) 
+    {
+        $self->update_queue($id);
+    }
+}
+
+# deeply copy an entry in the time table
+sub deep_copy_entry
+{
+    my ($self,$entry) = @_;
+
+    my $args = [ @{$entry->{args}} ];
+    my $copied_entry = { %$entry };
+    $copied_entry->{args} = $args;
+    return $copied_entry;
+}
+
+# Execute a subroutine whose time has come
+sub execute 
+{ 
+  my $self = shift;
+  my $index = shift;
+  my $cfg = shift || $self->{cfg};
+  my $entry = $self->get_entry($index) 
+    || die "Internal: No entry with index $index found in ",Dumper([$self->list_entries()]);
+
+  my $pid;
+
+
+  my $log = $cfg->{log};
+
+  unless ($cfg->{nofork})
+  {
+      if ($pid = fork) 
+      {
+          # Parent
+          $log->(0,"Schedule::Cron - Forking child PID $pid") if $log;
+          # Register PID
+          $STARTEDCHILD{$pid} = 1;
+          return;
+      } 
+  }
+  
+  # Child
+  my $dispatch = $entry->{dispatcher};
+  die "No subroutine provided with $dispatch" 
+    unless ref($dispatch) eq "CODE";
+  my $args = $entry->{args};
+  
+  my @args = ();
+  if (defined($args) && defined($args->[0])) 
+  {
+      push @args,@$args;
+  }
+
+
+  my $args_label = @args ? "with (".join(",",$self->prepare_args(@args)).")" : "";
+  $0 = $self->get_process_prefix()." Dispatch $args_label"
+    unless $cfg->{nofork};
+  $log->(0,"Schedule::Cron - Starting job $index $args_label")
+    if $log;
+
+  if ($cfg->{catch})
+  {
+      # Evaluate dispatcher
+      eval
+      {
+          &$dispatch(@args);
+      };
+      if ($@)
+      {
+          $log->(2,"Schedule::Cron - Error within job $index: $@")
+            if $log;
+      }
+  }
+  else
+  {
+      # Let dispatcher die if needed.
+      &$dispatch(@args);
+  }
+
+  $log->(0,"Schedule::Cron - Finished job $index") if $log;
+  exit unless $cfg->{nofork};
+}
+
+# Udate the scheduler queue with a new entry
+sub update_queue 
+{ 
+    my $self = shift;
+    
+    my $index = shift;
+    
+    my $entry = $self->get_entry($index);
+    
+    my $new_time = $self->get_next_execution_time($entry->{time});
+    dbg "Updating Queue: ",scalar(localtime($new_time));
+    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
+    #  dbg "Queue now: ",Dumper($self->{queue});
+}
+
+
+# The heart of the module.
+# calulate the next concrete date
+# for execution from a cronta entry
+sub calc_time 
+{ 
+    my $self = shift;
+    my $now = shift;
+    my $expanded = shift;
+
+    my $offset = ($expanded->[5] ? 1 : 60);
+    my ($now_sec,$now_min,$now_hour,$now_mday,$now_mon,$now_wday,$now_year) = 
+      (localtime($now+$offset))[0,1,2,3,4,6,5];
+    $now_mon++; 
+    $now_year += 1900;
+
+    # Notes on variables set:
+    # $now_... : the current date, fixed at call time
+    # $dest_...: date used for backtracking. At the end, it contains
+    #            the desired lowest matching date
+    
+    my ($dest_mon,$dest_mday,$dest_wday,$dest_hour,$dest_min,$dest_sec,$dest_year) = 
+      ($now_mon,$now_mday,$now_wday,$now_hour,$now_min,$now_sec,$now_year);
+    
+    while ($dest_year <= $now_year + 1) 
+    { # Airbag...
+        dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday";
+        
+        
+        # Check month:
+        if ($expanded->[3]->[0] ne '*') 
+        {
+            unless (defined ($dest_mon = $self->get_nearest($dest_mon,$expanded->[3]))) 
+            {
+                $dest_mon = $expanded->[3]->[0];
+                $dest_year++;
+            } 
+        } 
+  
+        # Check for day of month:
+        if ($expanded->[2]->[0] ne '*') 
+        {           
+            if ($dest_mon != $now_mon) 
+            {      
+                $dest_mday = $expanded->[2]->[0];
+            } 
+            else 
+            {
+                unless (defined ($dest_mday = $self->get_nearest($dest_mday,$expanded->[2]))) 
+                {
+                    # Next day matched is within the next month. ==> redo it
+                    $dest_mday = $expanded->[2]->[0];
+                    $dest_mon++;
+                    if ($dest_mon > 12) 
+                    {
+                        $dest_mon = 1;
+                        $dest_year++;
+                    }
+                    dbg "Backtrack mday: $dest_mday/$dest_mon/$dest_year";
+                    next;
+                }
+            }
+        } 
+        else 
+        {
+            $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
+        }
+  
+        # Check for day of week:
+        if ($expanded->[4]->[0] ne '*') 
+        {
+            $dest_wday = $self->get_nearest($dest_wday,$expanded->[4]);
+            $dest_wday = $expanded->[4]->[0] unless $dest_wday;
+    
+            my ($mon,$mday,$year);
+            #      dbg "M: $dest_mon MD: $dest_mday WD: $dest_wday Y:$dest_year";
+            $dest_mday = 1 if $dest_mon != $now_mon;
+            my $t = parsedate(sprintf("%4.4d/%2.2d/%2.2d",$dest_year,$dest_mon,$dest_mday));
+            ($mon,$mday,$year) =  
+              (localtime(parsedate("$WDAYS[$dest_wday]",PREFER_FUTURE=>1,NOW=>$t-1)))[4,3,5]; 
+            $mon++;
+            $year += 1900;
+            
+            dbg "$mday/$mon/$year";
+            if ($mon != $dest_mon || $year != $dest_year) {
+                dbg "backtracking";
+                $dest_mon = $mon;
+                $dest_year = $year;
+                $dest_mday = 1;
+                $dest_wday = (localtime(parsedate(sprintf("%4.4d/%2.2d/%2.2d",
+                                                          $dest_year,$dest_mon,$dest_mday))))[6];
+                next;
+            }
+            
+            $dest_mday = $mday;
+        } 
+        else 
+        {
+            unless ($dest_mday) 
+            {
+                $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
+            }
+        }
+  
+        # Check for hour
+        if ($expanded->[1]->[0] ne '*') 
+        {
+            if ($dest_mday != $now_mday) 
+            {
+                $dest_hour = $expanded->[1]->[0];
+            } 
+            else 
+            {
+#       dbg "Checking for next hour $dest_hour";
+                unless (defined ($dest_hour = $self->get_nearest($dest_hour,$expanded->[1]))) 
+                {
+                    # Hour to match is at the next day ==> redo it
+                    $dest_hour = $expanded->[1]->[0];
+                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
+                    ($dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                      (localtime(parsedate("+ 1 day",NOW=>$t)))[3,4,5,6];
+                    $dest_mon++; 
+                    $dest_year += 1900;
+                    next; 
+                }
+            }
+        } 
+        else 
+        {
+            $dest_hour = ($dest_mday == $now_mday ? $dest_hour : 0);
+        }
+    
+        # Check for minute
+        if ($expanded->[0]->[0] ne '*') 
+        {
+            if ($dest_hour != $now_hour) 
+            {
+                $dest_min = $expanded->[0]->[0];
+            } 
+            else 
+            {
+                unless (defined ($dest_min = $self->get_nearest($dest_min,$expanded->[0]))) 
+                {
+                    # Minute to match is at the next hour ==> redo it
+                    $dest_min = $expanded->[0]->[0];
+                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
+                    ($dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                      (localtime(parsedate(" + 1 hour",NOW=>$t)))  [2,3,4,5,6];
+                    $dest_mon++;
+                    $dest_year += 1900;
+                    next;
+                }
+            }
+        } 
+        else 
+        {
+            $dest_min = ($dest_hour == $now_hour ? $dest_min : 0);
+        }
+
+        # Check for seconds
+        if ($expanded->[5])
+        {
+            if ($expanded->[5]->[0] ne '*')
+            {
+                if ($dest_min != $now_min) 
+                {
+                    $dest_sec = $expanded->[5]->[0];
+                } 
+                else 
+                {
+                    unless (defined ($dest_sec = $self->get_nearest($dest_sec,$expanded->[5]))) 
+                    {
+                        # Second to match is at the next minute ==> redo it
+                        $dest_sec = $expanded->[5]->[0];
+                        my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                                  $dest_hour,$dest_min,$dest_sec,
+                                                  $dest_year,$dest_mon,$dest_mday));
+                        ($dest_min,$dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                          (localtime(parsedate(" + 1 minute",NOW=>$t)))  [1,2,3,4,5,6];
+                        $dest_mon++;
+                        $dest_year += 1900;
+                        next;
+                    }
+                }
+            } 
+            else 
+            {
+                $dest_sec = ($dest_min == $now_min ? $dest_sec : 0);
+            }
+        }
+        else
+        {
+            $dest_sec = 0;
+        }
+
+        
+        # We did it !!
+        my $date = sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                           $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday);
+        dbg "Next execution time: $date ",
+          $WDAYS[$dest_wday];
+        return parsedate($date);
+    }
+}
+
+# get next entry in list or 
+# undef if is the highest entry found
+sub get_nearest 
+{ 
+  my $self = shift;
+  my $x = shift;
+  my $to_check = shift;
+  foreach my $i (0 .. $#$to_check) 
+  {
+      if ($$to_check[$i] >= $x) 
+      {
+          return $$to_check[$i] ;
+      }
+  }
+  return undef;
+}
+
+
+# prepare a list of object for pretty printing e.g. in the process list
+sub prepare_args {
+    my $self = shift;
+    my @args = @_;
+    my @ret = ();
+    for my $arg (@args)
+    {
+        if (ref($arg) eq 'HASH') 
+        {
+            my $val = "{";
+            foreach my $key (keys %{$arg}) 
+            {
+                $val .= "$key=>".$args[0]->{$key}.", ";
+            }
+            if (length($val)>1)
+            {
+                chop $val; chop $val;
+            }
+            $val .= "}";
+            push @ret,$val;
+        } 
+        else
+        {
+            push @ret,$arg;
+        }         
+    }
+    return @ret;
+}
+
+# get the prefix to use when setting $0
+sub get_process_prefix { 
+    my $self = shift;
+    my $prefix = $self->{cfg}->{processprefix} || "Schedule::Cron";
+    return $prefix;
+}
+
+# our very own debugging routine
+# ('guess everybody has its own style ;-)
+sub dbg  
+{
+  if ($DEBUG) 
+  {
+      my $args = join('',@_) || "";
+      my $caller = (caller(1))[0];
+      my $line = (caller(0))[2];
+      $caller ||= $0;
+      if (length $caller > 22) 
+      {
+          $caller = substr($caller,0,10)."..".substr($caller,-10,10);
+      }
+      print STDERR sprintf ("%02d:%02d:%02d [%22.22s %4.4s]  %s\n",
+                            (localtime)[2,1,0],$caller,$line,$args);
+  }
+}
+
+# Helper method for reporting bugs concerning calculation
+# of execution bug:
+*bug = \&report_exectime_bug;   # Shortcut
+sub report_exectime_bug 
+{
+  my $self = shift;
+  my $endless = shift;
+  my $time = time;
+  my $inp;
+  my $now = $self->time_as_string($time);
+  my $email;
+
+  do 
+  {
+      while (1) 
+      {
+          $inp = $self->get_input("Reference time\n(default: $now)  : ");
+          if ($inp) 
+          {
+              parsedate($inp) || (print "Couldn't parse \"$inp\"\n",next);
+              $now = $inp;
+          }
+          last;
+      }
+      my $now_time = parsedate($now);
+    
+      my ($next_time,$next);
+      my @entries;
+      while (1) 
+      {
+          $inp = $self->get_input("Crontab time (5 columns)            : ");
+          @entries = split (/\s+/,$inp);
+          if (@entries != 5) 
+          {
+              print "Invalid crontab entry \"$inp\"\n";
+              next;
+          }
+          eval 
+          { 
+              local $SIG{ALRM} = sub {  die "TIMEOUT" };
+              alarm(60);
+              $next_time = Schedule::Cron->get_next_execution_time(\@entries,$now_time);
+              alarm(0);
+          };
+          if ($@) 
+          {
+              alarm(0);
+              if ($@ eq "TIMEOUT") 
+              {
+                  $next_time = -1;
+              } else 
+              {
+                  print "Invalid crontab entry \"$inp\" ($@)\n";
+                  next;
+              }
+          }
+        
+          if ($next_time > 0) 
+          {
+              $next = $self->time_as_string($next_time);
+          } else 
+          {
+              $next = "Run into infinite loop !!";
+          }
+          last;
+      }
+    
+      my ($expected,$expected_time);
+      while (1) 
+      {
+          $inp = $self->get_input("Expected time                       : ");
+          unless ($expected_time = parsedate($inp)) 
+          {
+              print "Couldn't parse \"$inp\"\n";
+              next;
+          } 
+          $expected = $self->time_as_string($expected_time);
+          last;
+      }
+    
+      # Print out bug report:
+      if ($expected eq $next) 
+      {
+          print "\nHmm, seems that everything's ok, or ?\n\n";
+          print "Calculated time: ",$next,"\n";
+          print "Expected time  : ",$expected,"\n";
+      } else 
+      {
+          print <<EOT;
+Congratulation, you hit a bug. 
+
+EOT
+          $email = $self->get_input("Your E-Mail Address (if available)  : ") 
+            unless defined($email);
+          $email = "" unless defined($email);
+      
+          print "\n","=" x 80,"\n";
+          print <<EOT;
+Please report the following lines
+to roland\@cpan.org
+
+EOT
+          print "# ","-" x 78,"\n";
+          print "Reftime: ",$now,"\n";
+          print "# Reported by : ",$email,"\n" if $email;
+          printf "%8s %8s %8s %8s %8s         %s\n",@entries,$expected;
+          print "# Calculated  : \n";
+          printf "# %8s %8s %8s %8s %8s         %s\n",@entries,$next;
+          unless ($endless) 
+          {
+              require Config;
+              my $vers = `uname -r 2>/dev/null` || $Config::Config{'osvers'} ;
+              chomp $vers;
+              my $osname = `uname -s 2>/dev/null` || $Config::Config{'osname'};
+              chomp $osname;
+              print "# OS: $osname ($vers)\n";
+              print "# Perl-Version: $]\n";
+              print "# Time::ParseDate-Version: ",$Time::ParseDate::VERSION,"\n";
+          }
+          print "# ","-" x 78,"\n";
+      }
+    
+      print "\n","=" x 80,"\n";
+  } while ($endless);
+}
+
+my ($input_initialized,$term);
+sub get_input 
+{ 
+  my $self = shift;
+  my $prompt = shift;
+  use vars qw($term);
+
+  unless (defined($input_initialized)) 
+  {
+      eval { require Term::ReadLine; };
+    
+      $input_initialized = $@ ? 0 : 1;
+      if ($input_initialized) 
+      {
+          $term = new Term::ReadLine;
+          $term->ornaments(0);
+      }
+  }
+  
+  unless ($input_initialized) 
+  {
+      print $prompt;
+      my $inp = <STDIN>;
+      chomp $inp;
+      return $inp;
+  } 
+  else 
+  {
+      chomp $prompt;
+      my @prompt = split /\n/s,$prompt;
+      if ($#prompt > 0)
+      {
+          print join "\n",@prompt[0..$#prompt-1],"\n";
+      }
+      my $inp = $term->readline($prompt[$#prompt]);
+      return $inp;
+  }
+}
+
+sub time_as_string 
+{ 
+  my $self = shift;
+  my $time = shift; 
+
+  my ($min,$hour,$mday,$month,$year,$wday) = (localtime($time))[1..6];
+  $month++;
+  $year += 1900;
+  $wday = $WDAYS[$wday];
+  return sprintf("%2.2d:%2.2d %2.2d/%2.2d/%4.4d %s",
+                 $hour,$min,$mday,$month,$year,$wday);
+}
+
+=back
+
+=head1 TODO
+
+=over 
+
+=item *
+
+Provide a C<reload()> method for reexaming the crontab file 
+
+=back
+
+
+=head1 COPYRIGHT
+
+Copyright 1999-2006 Roland Huss.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=head1 AUTHOR
+
+                                                    ...roland
+
+=cut
+
+1;
+
+
+
+
diff --git a/MANIFEST b/MANIFEST
new file mode 100644
index 0000000..6047947
--- /dev/null
+++ b/MANIFEST
@@ -0,0 +1,15 @@
+ChangeLog
+CHANGES
+Cron.pm
+Makefile.PL
+MANIFEST			This list of files
+META.yml
+README
+t/callbackreschedule.t
+t/entry.t
+t/execution_time.t
+t/load_crontab.t
+t/nofork.t
+t/sighandler.t
+t/startup.t
+t/test.crontab
diff --git a/META.yml b/META.yml
new file mode 100644
index 0000000..bd09c6a
--- /dev/null
+++ b/META.yml
@@ -0,0 +1,11 @@
+# http://module-build.sourceforge.net/META-spec.html
+#XXXXXXX This is a prototype!!!  It will change in the future!!! XXXXX#
+name:         Schedule-Cron
+version:      0.97
+version_from: Cron.pm
+installdirs:  site
+requires:
+    Time::ParseDate:               99.00
+
+distribution_type: module
+generated_by: ExtUtils::MakeMaker version 6.30
diff --git a/Makefile.PL b/Makefile.PL
new file mode 100644
index 0000000..a1c9fb6
--- /dev/null
+++ b/Makefile.PL
@@ -0,0 +1,12 @@
+use ExtUtils::MakeMaker;
+WriteMakefile
+  (
+   NAME => "Schedule::Cron",
+   VERSION_FROM => "Cron.pm",
+   ($] >= 5.005
+      ? (ABSTRACT   => 'cron-like scheduler',
+         AUTHOR     => 'Roland Huss (roland@consol.de)')
+      : ()),
+   PREREQ_PM => { "Time::ParseDate" => '99.00'},
+   'dist' => {COMPRESS=>'gzip',SUFFIX=>'gz'}
+  );
diff --git a/README b/README
new file mode 100644
index 0000000..f001a1c
--- /dev/null
+++ b/README
@@ -0,0 +1,150 @@
+			    Schedule::Cron
+			    ==============
+
+This module provides  a simple but complete cron  like scheduler.  I.e
+this modules can be  used for periodically executing Perl subroutines.
+The  dates  and  parameters  for  the subroutines  to  be  called  are
+specified with a format known as crontab entry (see manpage crontab(5)
+or documentation of Schedule::Cron).
+
+The   philosophy  behind   Schedule::Cron  is   to   call  subroutines
+periodically from  within one single  Perl program instead  of letting
+cron  trigger several  (possibly different)  Perl  scripts. Everything
+under  one  roof.  Furthermore  Schedule::Cron  provides mechanism  to
+create crontab entries dynamically, which isn't that easy with cron.
+
+Schedule::Cron  knows  about  all   extensions  (well,  at  least  all
+extensions I'm aware of, i.e those  of the so called "Vixie" cron) for
+crontab entries like ranges  including 'steps', specification of month
+and days of the week by name or coexistence of lists and ranges in the
+same field. And  even a bit more (like lists  and ranges with symbolic
+names).
+
+This module is rather effective concerning system load.  It calculates
+the execution  dates in advance and  will sleep until  those dates are
+reached (and  wont wake  up every minute  to check for  execution like
+cron).   However, it  relies on  the accuracy  of your  sleep() system
+call.
+
+EXAMPLES
+--------
+
+ * Minimalistic:
+
+      use Schedule::Cron;
+
+      my $dispatcher = sub { print "Time to start...\n"};
+      my $cron = new Schedule::Cron($dispatcher);	 
+
+      $cron->add_entry("0 7 * * *");
+      $cron->run;             # Runs forever...
+
+ * A bit more complex:
+
+      use Schedule::Cron;
+
+      my $cron = new Schedule::Cron(  sub { print "@_","\n" },
+                                      file  => "check_links.sched",
+                                      eval  => 1);
+
+      sub check_links { 
+        my $args = shift;
+        print "URL:   ",$args->{url},"\n";
+        print "Depth: ",$args->{depth},"\n";
+      } 
+
+      $cron->add_entry("0-40/5,55 3,22 * Jan-Nov Fri",
+                       { sub  => \&check_links,
+                         args => [ { url   => "http://www.consol.de", 
+                                     depth => 2 } ],
+                         eval => 0 });
+      # ... add more ....
+      $cron->run(detach=>1,pid_file=>"/var/run/checker.pid");
+      # ... continue ...
+
+ * simple cron replacement (for a single crontab file):
+   
+      use Schedule::Cron;
+      my $cron = new Schedule::Cron(sub { system(shift) },
+                                    file => "/var/spool/crontab.perl");
+      $cron->run();
+      
+PREREQUISITES
+-------------
+
+In order  to install and use  this package you will  need Perl version
+5.005  or better.   Furthermore  you need  the module  Time::ParseDate
+(contained in the Time-modules-xx.xxxxx) available on CPAN.
+
+You need a fork()-aware Perl for dispatching the cron jobs. This might
+change in the future. On systems without a fork() system call you can
+use the 'nofork' option to run your jobs within the current process.
+
+OS-DEPENDENCIES
+---------------
+
+Schedule::Cron was tested on a Redhat Linux-Box, but it should work on
+any UNIX  Box (still  to be  tested). In depends  on some  UNIX system
+calls for starting jobs and detaching itself to the background:
+
+  * It uses fork() for starting jobs
+  * For  detaching it  uses either  setsid (POSIX)  or the  ioctl call
+    TIOCNOTTY
+
+So at  the moment, it probably  won't run on any  'foreign' ports like
+the Win32- or MacOs-Port.
+
+These restrictions might be relaxed in the future.
+
+INSTALLATION
+------------
+
+As usual:
+
+   perl Makefile.PL
+   make
+   make test
+   make install
+
+See the  documentation for  Schedule::Cron for a  detailed description
+and further usage examples.
+
+REPORTING BUGS
+--------------
+
+This module  is still in alpha  stage, so I expect  probably some bugs
+showing  up. I.e.  the  calculation of  the next  execution time  of a
+specific  crontab  entry  might  fail in  some  obscure  circumstances
+(though I did what I could to test it thoroughly).
+
+If  you  meet  a bug  (say  hello  to  it  ;-),  please report  it  to
+roland@consol.de with  a subject like  "Schedule::Cron Bug-Report". In
+addition of a  problem description, please add a  short description of
+you OS, your  Perl version and the version  of Time::ParseDate you are
+using. If some of the provided tests fail, include the output of 'make
+test TEST_VERBOSE=1' as well.
+
+If you suspect,  that the date calculation of  the next execution time
+is buggy, please  use the following interactive command  to generate a
+bug report.
+
+   perl -MSchedule::Cron -e 'bug Schedule::Cron'
+
+You will be asked for a  reference time (default: the current time), a
+crontab  date  pattern  (with  five  columns) and  the  expected  next
+execution date  (relative to  the reference time).   The dates  can be
+specified in  a format understood by  'parsedate' from Time::ParseDate
+(like 'now  + 5  days').  Please include  the output of  this command.
+
+COPYRIGHT
+---------
+
+Copyright 1999-2006 Roland Huss.
+
+This library is  free software; you can redistribute  it and/or modify
+it under the same terms as Perl itself.
+
+Enjoy it...
+							    ...roland
+                                                       roland@cpan.org
+
diff --git a/svn-commit.tmp b/svn-commit.tmp
new file mode 100644
index 0000000..e5588d2
--- /dev/null
+++ b/svn-commit.tmp
@@ -0,0 +1,4 @@
+Initial import
+-- Diese und die folgenden Zeilen werden ignoriert --
+
+A    .
diff --git a/t/callbackreschedule.t b/t/callbackreschedule.t
new file mode 100644
index 0000000..ef8a0ba
--- /dev/null
+++ b/t/callbackreschedule.t
@@ -0,0 +1,41 @@
+#!perl -w
+
+# Check that rescheduling entries within an entry callback works properly
+# in nofork mode.
+#
+# by Andrew Danforth <acd@weirdness.net> based on existing testcases
+
+use Test::More tests => 1;
+use Schedule::Cron;
+
+$| = 1;
+
+my $cron = new Schedule::Cron(\&dispatch_1,{nofork => 1});
+my $job1count = 0;
+my $job2count = 0;
+
+sub dispatch_1 {
+   print "# Job 1.1, job1count: $job1count, job2count: $job2count\n";
+   if ($job1count++ == 0) {
+      $cron->clean_timetable;
+      $cron->add_entry("* * * * * 0-59/2", \&dispatch_2);
+      $cron->add_entry("* * * * * 1-59/2");
+   } else {
+      die "ok\n" if $job2count;
+      die "job2 never ran";
+   }
+}
+
+sub dispatch_2 {
+   print "# Job 1.2, job1count: $job1count, job2count: $job2count\n";
+   if ($job2count++) {
+      die "job1 got lost -- job2 ran again before job1";
+   }
+}
+
+$cron->add_entry("* * * * * 1-59/2");
+eval
+{
+    $cron->run();
+};
+ok($@ eq "ok\n","rescheduled jobs work properly");
diff --git a/t/entry.t b/t/entry.t
new file mode 100644
index 0000000..411c8d4
--- /dev/null
+++ b/t/entry.t
@@ -0,0 +1,71 @@
+#
+# Test management methods for adding/deleting/updating entries
+use Test::More tests => 19;
+
+use Schedule::Cron;
+use Data::Dumper;
+use strict;
+
+my $dispatcher = sub { print "Dispatcher\n"};
+my $special_dispatch = sub { print "Special Dispatcher\n"};
+my $cron = new Schedule::Cron($dispatcher);
+
+eval
+{
+    $cron->add_entry("*");
+};
+ok($@," invalid add arguments: $@");
+
+eval
+{
+    $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
+                                  'arguments'  => [ "first",2,"third" ],
+                                  'eval'       => 1});
+};
+ok($@," invalid add arguments: $@");
+
+# get
+my $timespec = "5 * * * *";
+$cron->add_entry($timespec,"doit");
+ok (scalar($cron->list_entries()) == 1,"3 list entries");
+my $entry = $cron->get_entry(0);
+ok ($entry->{time} eq $timespec,"entry 0 timespec");
+ok ($entry->{dispatcher} eq $dispatcher,"entry 0 dispatcher");
+ok ($entry->{args}->[0] eq "doit","entry 0 args");
+ok (!defined($cron->get_entry(2)),"entry: invalid index");
+
+# Add two extras
+$cron->add_entry($timespec,$special_dispatch);
+my $timespec3 = "* * * * * */2";
+$cron->add_entry($timespec3,"yet","some","arguments");
+
+ok (scalar($cron->list_entries()) == 3,"3 list entries");
+ok ($cron->get_entry(1)->{dispatcher} eq $special_dispatch,"entry 1 dispatcher");
+my $args_2 = [ 10,12,13 ];
+my $timespec_2 = "12 13 7 7 *";
+my $old_entry = $cron->update_entry(1,{time => $timespec_2,args => $args_2});
+
+# Update
+ok ($old_entry->{time} eq $timespec && $old_entry->{dispatcher} == $special_dispatch 
+    && @{$old_entry->{args}} == 0,
+    "update: old entry");
+$entry = $cron->get_entry(1);
+ok ($entry->{time} eq $timespec_2 && $entry->{dispatcher} eq $dispatcher,
+   "update: new entry");
+ok ($entry->{args} != $args_2,"update: deep copy");
+ok (scalar(grep { $args_2->[$_] == $entry->{args}->[$_] } (0,1,2)) == 3,"update: deep copy 2");
+
+# Delete
+$old_entry = $cron->delete_entry(1);
+ok ($old_entry->{time} eq $timespec_2 && $entry->{dispatcher} eq $dispatcher,"delete: old entry");
+ok (scalar($cron->list_entries) == 2,"delete: nr. entries");
+$entry = $cron->get_entry(1);
+ok ($entry->{time} eq $timespec3 && $entry->{dispatcher} == $dispatcher &&
+   $entry->{args}->[1] eq "some","delete: splicing");
+$old_entry = $cron->delete_entry(0);
+ok ($old_entry->{time} eq $timespec && $entry->{dispatcher} eq $dispatcher,"delete: old entry (2)");
+ok (scalar($cron->list_entries) == 1,"delete: nr. entries");
+
+# Clean all
+$cron->clean_timetable;
+ok (scalar($cron->list_entries) == 0,"clean");
diff --git a/t/execution_time.t b/t/execution_time.t
new file mode 100644
index 0000000..0fdc40d
--- /dev/null
+++ b/t/execution_time.t
@@ -0,0 +1,146 @@
+#!perl -w
+
+use Test::More;
+use Schedule::Cron;
+use Time::ParseDate;
+
+my $time;
+
+while (defined($_=<DATA>) && $_ !~ /end/i) {
+  chomp;
+  if (/^Reftime:\s*(.*)$/) {
+    $time = $1;
+    $time =~ s/\#.*$//;
+    $time = parsedate($time,UK=>1);
+    next;
+  }
+  s/^\s*(.*)\s*/$1/;
+  next if /^\#/ || /^$/;
+  my @args = split(/\s+/,$_,6);
+  my $date;
+
+  my $rest = pop @args;
+  my ($col6,$more_args) = split(/\s+/,$rest,2);
+  if ($col6 =~ /^[\d\-\*\,\/]+$/)
+  {
+      push @args,$col6;
+      $date = $more_args;
+  }
+  else
+  {
+      $date = $rest;
+  }
+
+  push @entries,[$time, \@args];
+  my $res_date = parsedate($date,UK=>1);
+  die "Internal error" unless $res_date;
+  push @results,$res_date;
+}
+
+my $cron = new Schedule::Cron(sub {});
+
+plan tests => scalar(@entries);
+
+my $i;
+for ($i=0;$i<=$#entries;$i++) 
+{
+    my $t = $cron->get_next_execution_time($entries[$i]->[1],$entries[$i]->[0]);
+    print "# Cron-Entry: ",join(" ",@{$entries[$i]->[1]}),"\n";
+    print "# Ref-Time:   ",scalar(localtime($entries[$i]->[0])),"\n";
+    print "# Calculated: ",scalar(localtime($t)),"\n";
+    print "# Expected:   ",scalar(localtime($results[$i])),"\n";
+    ok($t == $results[$i]);
+} 
+__DATA__
+Reftime: Mon Dec 27 20:14:14 1999
+
+# Minutes:
+# ========
+
+      *      *     *     *     *     0      20:15 27/12/1999 Monday
+     20      *     *     *     *            20:20 27/12/1999 Monday
+  10-50      *     *     *     *            20:15 27/12/1999 Monday
+13-30/4      *     *     *     *            20:17 27/12/1999 Monday
+     10      *     *     *     *            21:10 27/12/1999 Monday
+  18,20      *     *     *     *            20:18 27/12/1999 Monday
+
+# Hours:
+# ======
+
+     *      21     *     *     *            21:00 27/12/1999 Monday
+     *      19     *     *     *            19:00 28/12/1999 Tuesday
+     * 10-23/5     *     *     *            20:15 27/12/1999 Monday
+     * 10-23/7     *     *     *            10:00 28/12/1999 Tuesday
+
+# Days-of-Month:
+# ==============
+
+        *        *       29        2        *         00:00 29/02/2000 Tuesday
+       23        4  23-30/3        *        *         04:23 29/12/1999 Wednesday
+       12       21       27        *        *         21:12 27/12/1999 Monday
+       12       19       27        *        *         19:12 27/01/2000 Thursday
+        *       18  21,15,8        *        *         18:00 08/01/2000 Saturday
+
+# Months:
+# =======
+
+       *        *        *       11        *         00:00 01/11/2000 Wednesday
+       *        *        *       12        *         20:15 27/12/1999 Monday
+       *        *        *        0        *         00:00 01/01/2000 Saturday
+      42        0        4  Jan-Dec        *         00:42 04/01/2000 Tuesday
+      42       21        4 Jan-Dec/2       *         21:42 04/01/2000 Tuesday
+      42       21        * Feb-Dec/2       *         21:42 27/12/1999 Monday
+      42       19        * Feb-Dec/2       *         19:42 28/12/1999 Tuesday
+      42       19       27 Feb-Dec/2       *         19:42 27/02/2000 Sunday
+
+# Days-of-Week:
+# =============
+
+       14       15        *  Dec,Jan        0         15:14 02/01/2000 Sunday
+       14       15        *  Dec,Jan        7         15:14 02/01/2000 Sunday
+        0       12        *        *  Mon-Fri         12:00 28/12/1999 Tuesday
+        *        *        *        *      Mon         20:15 27/12/1999 Monday
+        0       21        *        *      Mon         21:00 27/12/1999 Monday
+        0       19        *        *      Mon         19:00 03/01/2000 Monday
+       13       14        *        * Sun-Sat/2        14:13 28/12/1999 Tuesday
+
+# Seconds
+      *      *     *     *     *   *        20:14:15 27/12/1999 Monday
+      *      *     *     *     *   5-10     20:15:05 27/12/1999 Monday
+      *      *     *     *     *   13-30/4  20:14:17 27/12/1999 Monday
+      *      *     *     *     *   18       20:14:18 27/12/1999 Monday
+ 
+# Horrible combinations ;-):
+# ==========================
+
+        0       21       27        *      Wed         21:00 27/12/1999 Monday
+        0       19       27        *      Wed         19:00 29/12/1999 Wednesday
+        0    19,21       27        *      Wed         21:00 27/12/1999 Monday
+20-30/5,17   19,21       27        *      Wed         21:17 27/12/1999 Monday
+
+# Check for parsedate-normalization
+# (thanx to Lars Holokowo)
+# =================================
+
+        1        3       30        6        *         03:01 30/06/2000 Monday
+        0       03       30        6        *         03:00 30/06/2000 Monday
+       00        3       30        6        *         03:00 30/06/2000 Monday
+        0        3       30        6        *         03:00 30/06/2000 Monday
+
+# Bug reported by Loic Paillotin
+# ==============================
+        5,10,25,30,35,40,45,50,55 *   *  * 	*         20:25 27/12/1999 Monday
+	    5,10,25,30,35,40,45,50,55 * * * *             20:25 27/12/1999 Monday
+        */5                       *   *  * 	*         20:15 27/12/1999 Monday
+
+end
+
+
+
+
+
+
+
+
+
+
diff --git a/t/load_crontab.t b/t/load_crontab.t
new file mode 100644
index 0000000..ba472e2
--- /dev/null
+++ b/t/load_crontab.t
@@ -0,0 +1,51 @@
+#!perl -w
+
+use Schedule::Cron;
+use File::Basename;
+use strict;
+
+my $crontab = dirname($0)."/test.crontab";
+
+my $cron;
+my @tests = (
+             qq(
+                \$cron = new Schedule::Cron( sub {},
+                                             file => "$crontab",
+                                             eval => 1)
+                ),
+             qq(
+                \$cron = new Schedule::Cron(sub {});
+                \$cron->load_crontab("$crontab");
+                ),
+             qq(
+                \$cron = new Schedule::Cron(sub {});
+                \$cron->load_crontab(file=>"$crontab",eval=>1);
+                ),
+             qq(
+                \$cron = new Schedule::Cron(sub {});
+                \$cron->load_crontab({file=>"$crontab",eval=>1});
+                )
+	     
+);
+
+print "1..",scalar(@tests),"\n";
+my $i = 1;
+foreach (@tests) {
+  eval $_;
+  
+  if ($@) { 
+    print "Error during loading of crontab file: $@\n";
+    print "not ok $i\n";
+  } else {
+    print "ok $i\n";
+  }
+#  print "Cron:\n",Dumper($cron);
+  $i++;
+}
+
+# Check for time parsing
+$cron = new Schedule::Cron(sub {});
+$cron->load_crontab($crontab);
+
+
+
diff --git a/t/nofork.t b/t/nofork.t
new file mode 100644
index 0000000..a558bdd
--- /dev/null
+++ b/t/nofork.t
@@ -0,0 +1,99 @@
+#!perl -w
+
+# Check no-fork option:
+use Test::More tests => 5;
+use Schedule::Cron;
+
+$| = 1;
+
+# Simple no fork execution
+my $toggle = 0;
+my $count = 0;
+my $dispatch_1 = 
+  sub {
+      print "# Job 1.1\n";
+      $toggle = 1;
+  };
+my $dispatch_2 = 
+  sub {
+      print "# Job 1.2\n";
+      if ($toggle)
+      {
+          pass("Second Job finished");
+          die "ok\n";
+      }
+      $count++;
+      fail("Job 1 has not run") if $count == 2;
+      sleep 2;
+  };
+
+my $cron = new Schedule::Cron($dispatch_1,{nofork => 1});
+$cron->add_entry("* * * * * *",$dispatch_2);
+$cron->add_entry("* * * * * *");
+eval
+{
+    $cron->run();
+};
+ok($@ eq "ok\n","Cron has been run: $@");
+
+# No fork with 'skip' option
+$count = 0;
+$dispatch_1 = 
+  sub {
+      print "# Job 2.1  ",scalar(localtime),"\n";
+      if ($count == 1)
+      {
+          pass("Skip test passed");
+          die "ok\n";
+      }
+      $count++;
+      sleep(3);
+      sleep(1) if ((localtime)[0] % 3 == 0);
+  };
+$dispatch_2 = 
+  sub {
+      print "# Job 2.2  ",scalar(localtime),"\n";
+      die "Job 2.2 should never run\n";
+  };
+
+$cron = new Schedule::Cron($dispatch_1,{nofork => 1,log => sub {print "# ",$_[1],"\n"}});
+$cron->add_entry("* * * * * *");
+$cron->add_entry("* * * * * */3",$dispatch_2);
+eval
+{
+    $cron->run(skip => 1);
+};
+ok($@ eq "ok\n","Cron has been run: $@");
+
+# No-Fork with 'catch' option.
+$count = 0;
+
+SKIP: {
+    eval { alarm 0 };
+    skip "alarm() not available", 1 if $@;
+
+    $dispatch_1 = 
+      sub {
+          $count++;
+          die "Exception";
+      };
+    
+    $SIG{ALRM} = sub { 
+        ok($count > 0,"Job has run");
+        exit;
+    };
+    
+    $cron = new Schedule::Cron($dispatch_1,{nofork => 1,log => sub {print "# ",$_[1],"\n"}});
+    $cron->add_entry("* * * * * *");
+    eval
+    {
+        alarm(3);
+        $cron->run(catch => 1);
+    };
+    ok(!$@,"Job has died: $@");
+ }
+
+
+
+
+
diff --git a/t/sighandler.t b/t/sighandler.t
new file mode 100644
index 0000000..1aa4d23
--- /dev/null
+++ b/t/sighandler.t
@@ -0,0 +1,31 @@
+#!perl -w
+
+# Startup Test:
+# $Id: sighandler.t,v 1.2 2006/11/27 13:42:52 roland Exp $
+
+use Schedule::Cron;
+use Test::More tests => 1;
+
+$| = 1;
+
+SKIP: {
+    eval { alarm 0 };
+    skip "alarm() not available", 1 if $@;
+
+    # Check, whether an already installed signalhandler is called
+    $SIG{CHLD} = sub { 
+        pass;
+        exit;
+    };
+    
+    $SIG{ALRM} = sub { 
+        fail;
+        exit;
+    };
+    
+    
+    my $cron = new Schedule::Cron(sub { sleep(1) });
+    $cron->add_entry("* * * * * */2");
+    alarm(5);
+    $cron->run;
+}
diff --git a/t/startup.t b/t/startup.t
new file mode 100644
index 0000000..be11919
--- /dev/null
+++ b/t/startup.t
@@ -0,0 +1,34 @@
+#!perl -w
+
+# Startup Test:
+# $Id: startup.t,v 1.7 2006/11/27 13:42:52 roland Exp $
+
+use Schedule::Cron;
+use Test::More tests => 1;
+
+$| = 1;
+#print STDERR " (may take a minute) ";
+
+SKIP: {
+    eval { alarm 0 };
+    skip "alarm() not available", 1 if $@;
+
+    $SIG{QUIT} = sub { 
+        alarm(0);
+        pass;
+        exit;
+    };
+    
+    $SIG{ALRM} = sub { 
+        fail;
+        exit;
+    };
+    
+    $cron = new Schedule::Cron(sub { kill QUIT, shift; alarm 0; });
+    $cron->add_entry("* * * * * *",$$);
+    
+    alarm(5);
+    $cron->run;
+}
+
+
diff --git a/t/test.crontab b/t/test.crontab
new file mode 100644
index 0000000..26933ec
--- /dev/null
+++ b/t/test.crontab
@@ -0,0 +1,69 @@
+# Minutes:
+# ========
+
+      *      *     *     *     *            qw(20:15 27/12/1999 Monday)
+     20      *     *     *     *            qw(20:20 27/12/1999 Monday)
+  10-50      *     *     *     *            qw(20:15 27/12/1999 Monday)
+13-30/4      *     *     *     *            qw(20:17 27/12/1999 Monday)
+     10      *     *     *     *            qw(21:10 27/12/1999 Monday)
+  18,20      *     *     *     *            qw(20:18 27/12/1999 Monday)
+
+# Hours:
+# ======
+
+     *      21     *     *     *            qw(21:00 27/12/1999 Monday)
+     *      19     *     *     *            qw(19:00 28/12/1999 Tuesday)
+     * 10-23/5     *     *     *            qw(20:15 27/12/1999 Monday)
+     * 10-23/7     *     *     *            qw(10:00 28/12/1999 Tuesday)
+
+# Days-of-Month:
+# ==============
+
+        *        *       29        2        *         qw(00:00 29/02/2000 Tuesday)
+       23        4  23-30/3        *        *         qw(04:23 29/12/1999 Wednesday)
+       12       21       27        *        *         qw(21:12 27/12/1999 Monday)
+       12       19       27        *        *         qw(19:12 27/01/2000 Thursday)
+        *       18  21,15,8        *        *         qw(18:00 08/01/2000 Saturday)
+
+# Months:
+# =======
+
+       *        *        *       11        *         qw(00:00 01/11/2000 Wednesday)
+       *        *        *       12        *         qw(20:15 27/12/1999 Monday)
+       *        *        *        0        *         qw(00:00 01/01/2000 Saturday)
+      42        0        4  Jan-Dec        *         qw(00:42 04/01/2000 Tuesday)
+      42       21        4 Jan-Dec/2       *         qw(21:42 04/01/2000 Tuesday)
+      42       21        * Feb-Dec/2       *         qw(21:42 27/12/1999 Monday)
+      42       19        * Feb-Dec/2       *         qw(19:42 28/12/1999 Tuesday)
+      42       19       27 Feb-Dec/2       *         qw(19:42 27/02/2000 Sunday)
+
+# Days-of-Week:
+# =============
+
+       14       15        *  Dec,Jan        0         qw(15:14 02/01/2000 Sunday)
+       14       15        *  Dec,Jan        7         qw(15:14 02/01/2000 Sunday)
+        0       12        *        *  Mon-Fri         qw(12:00 28/12/1999 Tuesday)
+        *        *        *        *      Mon         qw(20:15 27/12/1999 Monday)
+        0       21        *        *      Mon         qw(21:00 27/12/1999 Monday)
+        0       19        *        *      Mon         qw(19:00 03/01/2000 Monday)
+       13       14        *        * Sun-Sat/2        qw(14:13 28/12/1999 Tuesday)
+
+
+# Horrible combinations ;-):
+# ==========================
+
+        0       21       27        *      Wed         qw(21:00 27/12/1999 Monday)
+        0       19       27        *      Wed         qw(19:00 29/12/1999 Wednesday)
+        0    19,21       27        *      Wed         qw(21:00 27/12/1999 Monday)
+20-30/5,17    19,21       27        *      Wed         qw(21:17 27/12/1999 Monday)
+
+
+# With seconds (6th column)
+# =========================
+       *         *        *        *        *     *         qw(seconds_test)
+       *         *        *        *        *     0-59/2    qw(seconds_test)
+       *         *        *        *        *     2,4,6     (5 +  4)."seconds_test"
+
+
+
+
-- 
cgit v1.2.3


From 599763d30234f383ecfa30e4282e088a199a2529 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 20 Feb 2009 15:10:05 +0000
Subject: removed

---
 svn-commit.tmp | 4 ----
 1 file changed, 4 deletions(-)
 delete mode 100644 svn-commit.tmp

diff --git a/svn-commit.tmp b/svn-commit.tmp
deleted file mode 100644
index e5588d2..0000000
--- a/svn-commit.tmp
+++ /dev/null
@@ -1,4 +0,0 @@
-Initial import
--- Diese und die folgenden Zeilen werden ignoriert --
-
-A    .
-- 
cgit v1.2.3


From 07ede9a16104964b69a7eca7d7a33e8e1d460bb6 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 22 Mar 2009 10:07:14 +0000
Subject: added tests

---
 t/after_job.t          | 34 ++++++++++++++++++++++++++++++++++
 t/callbackreschedule.t |  2 +-
 t/entry.t              |  1 +
 t/kwalitee.t           |  6 ++++++
 t/pod.t                |  6 ++++++
 t/pod_coverage.t       |  8 ++++++++
 t/pretty_print_args.t  | 14 ++++++++++++++
 7 files changed, 70 insertions(+), 1 deletion(-)
 create mode 100644 t/after_job.t
 create mode 100644 t/kwalitee.t
 create mode 100644 t/pod.t
 create mode 100644 t/pod_coverage.t
 create mode 100644 t/pretty_print_args.t

diff --git a/t/after_job.t b/t/after_job.t
new file mode 100644
index 0000000..5c48666
--- /dev/null
+++ b/t/after_job.t
@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+
+# Test for after_job callbak
+
+use Test::More tests => 3;
+use Schedule::Cron;
+use strict;
+
+my $count = 0;
+my $cron =new Schedule::Cron(\&dispatch,{nofork => 1,after_job => \&after_callback});
+
+$cron->add_entry("* * * * * 0-59/1",{args => [ "eins", "zwei"]});
+eval {
+    $cron->run();
+};
+is($@,"e1\n","Second call must finish test");
+
+
+sub dispatch {
+    my @args;
+    if ($count == 0) {
+        $count = 1;
+        return "t1";
+    } elsif ($count == 1) {
+        die "e1\n";
+    }
+
+}
+
+sub after_callback {
+    my ($ret,@args) = @_;
+    is($ret,"t1","Return value must match");
+    is_deeply(\@args,["eins","zwei" ],"Arguments must match");
+}
diff --git a/t/callbackreschedule.t b/t/callbackreschedule.t
index ef8a0ba..0c788c3 100644
--- a/t/callbackreschedule.t
+++ b/t/callbackreschedule.t
@@ -29,7 +29,7 @@ sub dispatch_1 {
 sub dispatch_2 {
    print "# Job 1.2, job1count: $job1count, job2count: $job2count\n";
    if ($job2count++) {
-      die "job1 got lost -- job2 ran again before job1";
+      die "job1 got lost -- job2 ran again before job1 a second time";
    }
 }
 
diff --git a/t/entry.t b/t/entry.t
index 411c8d4..a9eade1 100644
--- a/t/entry.t
+++ b/t/entry.t
@@ -1,3 +1,4 @@
+#!/usr/bin/perl
 #
 # Test management methods for adding/deleting/updating entries
 use Test::More tests => 19;
diff --git a/t/kwalitee.t b/t/kwalitee.t
new file mode 100644
index 0000000..7c25a3b
--- /dev/null
+++ b/t/kwalitee.t
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+use Test::More;
+
+eval { require Test::Kwalitee; Test::Kwalitee->import() };
+
+plan( skip_all => 'Test::Kwalitee not installed; skipping' ) if $@;
diff --git a/t/pod.t b/t/pod.t
new file mode 100644
index 0000000..156a744
--- /dev/null
+++ b/t/pod.t
@@ -0,0 +1,6 @@
+#!/usr/bin/perl
+
+use Test::More;
+eval "use Test::Pod 1.00";
+plan skip_all => "Test::Pod 1.00 required for testing POD" if $@;
+all_pod_files_ok();
diff --git a/t/pod_coverage.t b/t/pod_coverage.t
new file mode 100644
index 0000000..1f13c12
--- /dev/null
+++ b/t/pod_coverage.t
@@ -0,0 +1,8 @@
+#!/usr/bin/perl
+
+use Test::More;
+eval "use Test::Pod::Coverage";
+plan skip_all => "Test::Pod::Coverage required for testing pod coverage" if $@;
+
+plan tests => 1;
+pod_coverage_ok( "Schedule::Cron",{trustme => [qr/^REAPER$/, qr/^bug$/, qr/^report_exectime_bug/]}, "Schedule::Cron is covered" );
diff --git a/t/pretty_print_args.t b/t/pretty_print_args.t
new file mode 100644
index 0000000..7a1322e
--- /dev/null
+++ b/t/pretty_print_args.t
@@ -0,0 +1,14 @@
+#!/usr/bin/perl
+
+use Test::More tests => 1;
+use Schedule::Cron;
+use strict;
+
+my @args = (
+            [ "bla", "blub", { "deeper" => 1, "and" => {deeper => "stop" } } ],
+            3,
+          { "blub" => "bla", 3 => 2 }
+           );     
+
+my $out = join(",",Schedule::Cron->_format_args(@args));
+like($out,qr/\['bla','blub',{.*?'and'\s*=>\s*'HASH\(.*?\)'.*?}\],3,{.*?'blub'\s*=>\s*'bla'.*?}/);
-- 
cgit v1.2.3


From b5dd5c49a975aa233bdca4d0ac867cbfae0ef490 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 22 Mar 2009 14:31:57 +0000
Subject: changed build process to use Build.PL

---
 Build.PL             |   34 ++
 CHANGES              |   10 +-
 ChangeLog            |   12 +
 Cron.pm              | 1592 -------------------------------------------------
 MANIFEST             |    8 +-
 META.yml             |   40 +-
 Makefile.PL          |   13 +-
 README               |    6 +-
 lib/Schedule/Cron.pm | 1605 ++++++++++++++++++++++++++++++++++++++++++++++++++
 9 files changed, 1708 insertions(+), 1612 deletions(-)
 create mode 100644 Build.PL
 delete mode 100644 Cron.pm
 create mode 100644 lib/Schedule/Cron.pm

diff --git a/Build.PL b/Build.PL
new file mode 100644
index 0000000..f69884b
--- /dev/null
+++ b/Build.PL
@@ -0,0 +1,34 @@
+#!/usr/bin/perl
+use Module::Build;
+my $build = Module::Build->new
+  (
+   module_name => "Schedule::Cron",
+   dist_author => 'Roland Huss (roland@cpan.org)',
+   abstract => 'Cron-like scheduler for Perl subroutines',
+   distribution_type => 'module',
+   installdirs => 'site',
+
+   license => "perl",
+   
+   requires => {
+                "Time::ParseDate" => "99.00",
+                "Data::Dumper" => "0"
+               },
+   
+   build_requires => {
+                      "Test::More" => "0",
+                      "Test" => "0"
+                     },                       
+   recommends => {
+                  "ioctl.ph" => 0,
+                  "sys::ioctl.ph" => 0,
+                  "Module::Build" => 0
+                 },
+   keywords => [  "Cron", "Scheduler", "Jon" ],
+   provides => {
+                "Schedule::Cron" => {
+                               file =>  "lib/Schedule/Cron.pm"
+                              }
+               }
+  );
+$build->create_build_script;
diff --git a/CHANGES b/CHANGES
index 64ceb41..07159b4 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,12 @@
+0.98
+
+- New option 'after_job' for new() which allows for a callback run after a 
+  job has been sucessfully run (RT #29040)
+- Argument logging is done using data dumper (RT #39499)
+- Private methods are now marked with _
+- Added tests for increasin kwallitee
+- Switched to Build.PL (Makefile.PL is still supported)
+
 0.97
 
 - Use POSIX only where available, otherwise fallback to an emulation of waipid.
@@ -12,7 +21,6 @@
 - Applied patch for #4917 in order to be smarter to existing SIGCHLD handler and to 
   reap only own childs.
 
-
 0.95 
 
 - If a scheduled method in 'nofork' manipulates the execution queue with 
diff --git a/ChangeLog b/ChangeLog
index 0cfc50c..7ed55be 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,15 @@
+2009-03-21  Roland Huss  <roland@consol.de>
+
+	* Cron.pm (_time_as_string): marked all private subs to start with '_'
+
+2009-03-20  Roland Huss  <roland@consol.de>
+
+	* t/pretty_print_args.t: Arguments are logged using Data::Dumper
+	in a terse format
+
+	* t/after_job.t: Added new option 'after_job' and test for it
+	which allows for a single callback after any job has been run.
+
 2006-11-27  Roland Huss  <roland@consol.de>
 
 	* Cron.pm (REAPER): Added support for plattforms where POSIX is
diff --git a/Cron.pm b/Cron.pm
deleted file mode 100644
index 21ae607..0000000
--- a/Cron.pm
+++ /dev/null
@@ -1,1592 +0,0 @@
-#!/usr/bin/perl -w
-
-# $Id: Cron.pm,v 1.16 2006/11/27 13:42:52 roland Exp $
-
-=head1 NAME
-
-Cron - cron-like scheduler for Perl subroutines
-
-=head1 SYNOPSIS
-
-  use Schedule::Cron;
-
-  # Subroutines to be called
-  sub dispatcher { 
-    print "ID:   ",shift,"\n"; 
-    print "Args: ","@_","\n";
-  }
-
-  sub check_links { 
-    # do something... 
-  }
-
-  # Create new object with default dispatcher
-  my $cron = new Schedule::Cron(\&dispatcher);
-
-  # Load a crontab file
-  $cron->load_crontab("/var/spool/cron/perl");
-
-  # Add dynamically  crontab entries
-  $cron->add_entry("3 4  * * *",ROTATE => "apache","sendmail");
-  $cron->add_entry("0 11 * * Mon-Fri",\&check_links);
-
-  # Run scheduler 
-  $cron->run(detach=>1);
-                   
-
-=head1 DESCRIPTION
-
-This module provides a simple but complete cron like scheduler.  I.e this
-modules can be used for periodically executing Perl subroutines.  The dates and
-parameters for the subroutines to be called are specified with a format known
-as crontab entry (L<"METHODS">, C<add_entry()> and L<crontab(5)>)
-
-The philosophy behind C<Schedule::Cron> is to call subroutines periodically
-from within one single Perl program instead of letting C<cron> trigger several
-(possibly different) perl scripts. Everything under one roof.  Furthermore
-C<Schedule::Cron> provides mechanism to create crontab entries dynamically,
-which isn't that easy with C<cron>.
-
-C<Schedule::Cron> knows about all extensions (well, at least all extensions I'm
-aware of, i.e those of the so called "Vixie" cron) for crontab entries like
-ranges including 'steps', specification of month and days of the week by name
-or coexistence of lists and ranges in the same field.  And even a bit more
-(like lists and ranges with symbolic names).
-
-=head1 METHODS
-
-=over 4
-
-=cut
-
-#'
-
-package Schedule::Cron;
-
-use Time::ParseDate;
-use Data::Dumper;
-
-use strict;
-use vars qw($VERSION  $DEBUG);
-use subs qw(dbg);
-
-my $HAS_POSIX;
-
-BEGIN {
-  eval { 
-    require POSIX;
-    import POSIX ":sys_wait_h";
-  };
-  $HAS_POSIX = $@ ? 0 : 1;
-}
-
-
-$VERSION = 0.97;
-
-our $DEBUG = 0;
-my %STARTEDCHILD = ();
-
-my @WDAYS = qw(
-                 Sunday
-                 Monday
-                 Tuesday
-                 Wednesday
-                 Thursday
-                 Friday
-                 Saturday
-                 Sunday
-                );
-
-my @ALPHACONV = (
-                 { },
-                 { },
-                 { },
-                 { qw(jan 1 feb 2 mar 3 apr 4 may 5 jun 6 jul 7 aug 8
-                      sep 9 oct 10 nov 11 dec 12) },
-                 { qw(sun 0 mon 1 tue 2 wed 3 thu 4 fri 5 sat 6)},
-                 {  }
-                );
-my @RANGES = ( 
-              [ 0,59 ],
-              [ 0,23 ],
-              [ 0,31 ],
-              [ 0,12 ],
-              [ 0,7  ],
-              [ 0,60 ]
-             );
-
-my @LOWMAP = ( 
-              {},
-              {},
-              { 0 => 1},
-              { 0 => 1},
-              { 7 => 0},
-              {},
-             );
-
-sub REAPER {
-    if ($HAS_POSIX)
-    {
-        # Only on platforms supporting POSIX semantisc
-        foreach my $pid (keys %STARTEDCHILD) {
-            my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
-            if ($res > 0) {
-                # We reaped a truly running process
-                delete $STARTEDCHILD{$pid};
-            }
-        }
-    } 
-    else
-    {
-        my $waitedpid = 0;
-        while($waitedpid != -1) {
-            $waitedpid = wait;
-        }
-    }
-}
-
-=item $cron = new Schedule::Cron($dispatcher,[extra args])
-
-Creates a new C<Cron> object.  C<$dispatcher> is a reference to a subroutine,
-which will be called by default.  C<$dispatcher> will be invoked with the
-arguments parameter provided in the crontab entry if no other subroutine is
-specified. This can be either a single argument containing the argument
-parameter literally has string (default behavior) or a list of arguments when
-using the C<eval> option described below.
-
-The date specifications must be either provided via a crontab like file or
-added explicitly with C<add_entry()> (L<"add_entry">).
-
-I<extra_args> can be a hash or hash reference for additional arguments.  The
-following parameters are recognized:
-
-=over
-
-=item file => <crontab>  
-
-
-Load the crontab entries from <crontab>
-
-=item eval =>  1
-
-Eval the argument parameter in a crontab entry before calling the subroutine
-(instead of literally calling the dispatcher with the argument parameter as
-string)
-
-=item nofork => 1
-
-Don't fork when starting the scheduler. Instead, the jobs are executed within
-current process. In your executed jobs, you have full access to the global
-variables of your script and hence might influence other jobs running at a
-different time. This behaviour is fundamentally different to the 'fork' mode,
-where each jobs gets its own process and hence a B<copy> of the process space,
-independent of each other job and the main process. This is due to the nature
-of the  C<fork> system call. 
-
-=item skip => 1
-
-Skip any pending jobs whose time has passed. This option is only useful in
-combination with C<nofork> where a job might block the execution of the
-following jobs for quite some time. By default, any pending job is executed
-even if its scheduled execution time has already passed. With this option set
-to true all pending which would have been started in the meantime are skipped. 
-
-=item catch => 1
-
-Catch any exception raised by a job. This is especially useful in combination with
-the C<nofork> option to avoid stopping the main process when a job raises an
-exception (dies).
-
-=item log => \&log_sub
-
-Install a logging subroutine. The given subroutine is called for several events
-during the lifetime of a job. This method is called with two arguments: A log
-level of 0 (info),1 (warning) or 2 (error) depending on the importance of the
-message and the message itself.
-
-For example, you could use I<Log4Perl> (L<http://log4perl.sf.net>) for logging
-purposes for example like in the following code snippet:
-
-   use Log::Log4perl;
-   use Log::Log4perl::Level;
-
-   my $log_method = sub {
-      my ($level,$msg) = @_;
-      my $DBG_MAP = { 0 => $INFO, 1 => $WARN, 2 => $ERROR };
-
-      my $logger = Log::Log4Perl->get_logger("My::Package");
-      $logger->log($DBG_MAP->{$level},$msg);
-   }
-  
-   my $cron = new Schedule::Cron(.... , log => $log_method);
-
-=item processprefix => <name>
-
-Cron::Schedule sets the process' name (i.e. C<$0>) to contain some informative
-messages like when the next job executes or with which arguments a job is
-called. By default, the prefix for this labels is C<Schedule::Cron>. With this
-option you can set it to something different. You can e.g. use C<$0> to include
-the original process name.
-
-=back
-
-=cut
-
-sub new 
-{
-    my $class = shift;
-    my $dispatcher = shift || die "No dispatching sub provided";
-    die "Dispatcher not a ref to a subroutine" unless ref($dispatcher) eq "CODE";
-    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
-    $cfg->{processprefix} = "Schedule::Cron" unless $cfg->{processprefix};
-    my $self = { 
-                cfg => $cfg,
-                dispatcher => $dispatcher,
-                queue => [ ],
-                map => { }
-             };
-    bless $self,(ref($class) || $class);
-    
-    $self->load_crontab if $cfg->{file};
-    $self;
-}
-
-=item $cron->load_crontab($file)
-
-=item $cron->load_crontab(file=>$file,[eval=>1])
-
-Loads and parses the crontab file C<$file>. The entries found in this file will
-be B<added> to the current time table with C<$cron-E<gt>add_entry>.
-
-The format of the file consists of cron commands containing of lines with at
-least 5 columns, whereas the first 5 columns specify the date.  The rest of the
-line (i.e columns 6 and greater) contains the argument with which the
-dispatcher subroutine will be called.  By default, the dispatcher will be
-called with one single string argument containing the rest of the line
-literally.  Alternatively, if you call this method with the optional argument
-C<eval=E<gt>1> (you must then use the second format shown above), the rest of
-the line will be evaled before used as argument for the dispatcher.
-
-For the format of the first 5 columns, please see L<"add_entry">.
-
-Blank lines and lines starting with a C<#> will be ignored. 
-
-There's no way to specify another subroutine within the crontab file.  All
-calls will be made to the dispatcher provided at construction time.
-
-If    you   want    to    start   up    fresh,    you   should    call
-C<$cron-E<gt>clean_timetable()> before.
-
-Example of a crontab fiqw(le:)
-
-   # The following line runs on every Monday at 2:34 am
-   34 2 * * Mon  "make_stats"
-   # The next line should be best read in with an eval=>1 argument
-   *  * 1 1 *    { NEW_YEAR => '1',HEADACHE => 'on' }
-
-=cut
-
-#'
-
-sub load_crontab 
-{
-  my $self = shift;
-  my $cfg = shift;
-
-  if ($cfg) 
-  {
-      if (@_) 
-      {
-          $cfg = ref($cfg) eq "HASH" ? $cfg : { $cfg,@_ };
-      } 
-      elsif (!ref($cfg)) 
-      {
-          my $new_cfg = { };
-          $new_cfg->{file} = $cfg;
-          $cfg = $new_cfg;
-      }
-  }
-  
-  my $file = $cfg->{file} || $self->{cfg}->{file} || die "No filename provided";
-  my $eval = $cfg->{eval} || $self->{cfg}->{eval};
-  
-  open(F,$file) || die "Cannot open schedule $file : $!";
-  my $line = 0;
-  while (<F>) 
-  {
-      $line++;
-      next if /^$/;
-      next if /^\s*#/;
-      chomp;
-      s/\s*(.*)\s*$/$1/;
-      my ($min,$hour,$dmon,$month,$dweek,$rest) = split (/\s+/,$_,6);
-      
-      my $time = [ $min,$hour,$dmon,$month,$dweek ];
-
-      # Try to check, whether an optional 6th column specifying seconds 
-      # exists: 
-      my $args;
-      if ($rest)
-      {
-          my ($col6,$more_args) = split(/\s+/,$rest,2);
-          if ($col6 =~ /^[\d\-\*\,\/]+$/)
-          {
-              push @$time,$col6;
-              dbg "M: $more_args";
-              $args = $more_args;
-          }
-          else
-          {
-              $args = $rest;
-          }
-      }
-      $self->add_entry($time,{ 'args' => $args, 'eval' => $eval});
-  }
-  close F;
-}
-
-=item $cron->add_entry($timespec,[arguments])
-
-Adds a new entry to the list of scheduled cron jobs.
-
-B<Time and Date specification>
-
-C<$timespec> is the specification of the scheduled time in crontab format
-(L<crontab(5)>) which contains five mandatory time and date fields and an
-optional 6th column. C<$timespec> can be either a plain string, which contains
-a whitespace separated time and date specification.  Alternatively,
-C<$timespec> can be a reference to an array containing the five elements for
-the date fields.
-
-The time and date fields are (taken mostly from L<crontab(5)>, "Vixie" cron): 
-
-   field          values
-   =====          ======
-   minute         0-59
-   hour           0-23
-   day of month   1-31 
-   month          1-12 (or as names)
-   day of week    0-7 (0 or 7 is Sunday, or as names )
-   seconds        0-59 (optional)
-
- A field may be an asterisk (*), which always stands for
- ``first-last''.
-
- Ranges of numbers are  allowed.  Ranges are two numbers
- separated  with  a  hyphen.   The  specified  range  is
- inclusive.   For example, 8-11  for an  ``hours'' entry
- specifies execution at hours 8, 9, 10 and 11.
-
- Lists  are allowed.   A list  is a  set of  numbers (or
- ranges)  separated by  commas.   Examples: ``1,2,5,9'',
- ``0-4,8-12''.
-
- Step  values can  be used  in conjunction  with ranges.
- Following a range with ``/<number>'' specifies skips of
- the  numbers value  through the  range.   For example,
- ``0-23/2'' can  be used in  the hours field  to specify
- command execution every  other hour (the alternative in
- the V7 standard is ``0,2,4,6,8,10,12,14,16,18,20,22'').
- Steps are  also permitted after an asterisk,  so if you
- want to say ``every two hours'', just use ``*/2''.
-
- Names can also  be used for the ``month''  and ``day of
- week''  fields.  Use  the  first three  letters of  the
- particular day or month (case doesn't matter).
-
- Note: The day of a command's execution can be specified
-       by two fields  -- day of month, and  day of week.
-       If both fields are restricted (ie, aren't *), the
-       command will be run when either field matches the
-       current  time.  For  example, ``30  4 1,15  * 5''
-       would cause a command to be run at 4:30 am on the
-       1st and 15th of each month, plus every Friday
-
-Examples:
-
- "8  0 * * *"         ==> 8 minutes after midnight, every day
- "5 11 * * Sat,Sun"   ==> at 11:05 on each Saturday and Sunday
- "0-59/5 * * * *"     ==> every five minutes
- "42 12 3 Feb Sat"    ==> at 12:42 on 3rd of February and on 
-                          each Saturday in February
- "32 11 * * * 0-30/2" ==> 11:32:00, 11:32:02, ... 11:32:30 every 
-                          day
-
-In addition, ranges or lists of names are allowed. 
-
-An optional sixth column can be used to specify the seconds within the
-minute. If not present, it is implicitely set to "0".
-
-B<Command specification>
-
-The subroutine to be executed when the the C<$timespec> matches can be
-specified in several ways.
-
-First, if the optional C<arguments> are lacking, the default dispatching
-subroutine provided at construction time will be called without arguments.
-
-If the second parameter to this method is a reference to a subroutine, this
-subroutine will be used instead of the dispatcher.
-
-Any additional parameters will be given as arguments to the subroutine to be
-executed.  You can also specify a reference to an array instead of a list of
-parameters.
-
-You can also use a named parameter list provided as an hashref.  The named
-parameters recognized are:
-
-=over
-
-=item subroutine      
-
-=item sub 
-
-Reference to subroutine to be executed
-
-=item arguments
-
-=item args
-
-Reference to array containing arguments to be use when calling the subroutine
-
-=item eval
-
-If true, use the evaled string provided with the C<arguments> parameter.  The
-evaluation will take place immediately (not when the subroutine is going to be
-called)
-
-=back
-
-Examples:
-
-   $cron->add_entry("* * * * *");
-   $cron->add_entry("* * * * *","doit");
-   $cron->add_entry("* * * * *",\&dispatch,"first",2,"third");
-   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
-                                 'arguments'  => [ "first",2,"third" ]});
-   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
-                                 'arguments'  => '[ "first",2,"third" ]',
-                                 'eval'       => 1});
-
-=cut 
-
-sub add_entry 
-{ 
-    my $self = shift;
-    my $time = shift;
-    my $args = shift || []; 
-    my $dispatch;
-    
-    #  dbg "Args: ",Dumper($time,$args);
-    
-    if (ref($args) eq "HASH") 
-    {
-        my $cfg = $args;
-        $args = undef;
-        $dispatch = $cfg->{subroutine} || $cfg->{sub};
-        $args = $cfg->{arguments} || $cfg->{args} || [];
-        if ($cfg->{eval} && $cfg) 
-        {
-            die "You have to provide a simple scalar if using eval" if (ref($args));
-            my $orig_args = $args;
-            dbg "Evaled args ",Dumper($args);
-            $args = [ eval $args ];
-            die "Cannot evaluate args (\"$orig_args\")"
-              if $@;
-        }
-    } 
-    elsif (ref($args) eq "CODE") 
-    {
-        $dispatch = $args;
-        $args = shift || [];
-    }
-    if (ref($args) ne "ARRAY") 
-    {
-        $args = [ $args,@_ ];
-    }
-
-    $dispatch ||= $self->{dispatcher};
-
-
-    my $time_array = ref($time) ? $time : [ split(/\s+/,$time) ];
-    die "Invalid number of columns in time entry (5 or 6)\n"
-      if ($#$time_array != 4 && $#$time_array !=5);
-    $time = join ' ',@$time_array;
-
-    #  dbg "Adding ",Dumper($time);
-    push @{$self->{time_table}},
-    {
-     time => $time,
-     dispatcher => $dispatch,
-     args => $args
-    };
-    
-    $self->{entries_changed} = 1;
-    #  dbg "Added Args ",Dumper($self->{args});
-    
-    my $index = $#{$self->{time_table}};
-    my $id = $args->[0];
-    $self->{map}->{$id} = $index if $id;
-    
-    return $#{$self->{time_table}};
-}
-
-=item @entries = $cron->list_entries()
-
-Return a list of cron entries. Each entry is a hash reference of the following
-form:
-
-  $entry = { 
-             time => $timespec,
-             dispatch => $dispatcher,
-             args => $args_ref
-           }
-
-Here C<$timespec> is the specified time in crontab format as provided to
-C<add_entry>, C<$dispatcher> is a reference to the dispatcher for this entry
-and C<$args_ref> is a reference to an array holding additional arguments (which
-can be an empty array reference). For further explanation of this arguments
-refer to the documentation of the method C<add_entry>.
-
-The order index of each entry can be used within C<update_entry>, C<get_entry>
-and C<delete_entry>. But be aware, when you are deleting an entry, that you
-have to refetch the list, since the order will have changed.
-
-Note that these entries are returned by value and were opbtained from the
-internal list by a deep copy. I.e. you are free to modify it, but this won't
-influence the original entries. Instead use C<update_entry> if you need to
-modify an exisiting crontab entry.
-
-=cut
-
-sub list_entries
-{
-    my ($self) = shift;
-    
-    my @ret;
-    foreach my $entry (@{$self->{time_table}})
-    {
-        # Deep copy $entry
-        push @ret,$self->deep_copy_entry($entry);
-    }
-    return @ret;
-}
-
-
-=item $entry = $cron->get_entry($idx)
-
-Get a single entry. C<$entry> is either a hashref with the possible keys
-C<time>, C<dispatch> and C<args> (see C<list_entries()>) or undef if no entry
-with the given index C<$idx> exists.
-
-=cut
-
-sub get_entry
-{
-    my ($self,$idx) = @_;
-
-    my $entry = $self->{time_table}->[$idx];
-    if ($entry)
-    {
-        return $self->deep_copy_entry($entry);
-    }
-    else
-    {
-        return undef;
-    }
-}
-
-=item $cron->delete_entry($idx)
-
-Delete the entry at index C<$idx>. Returns the deleted entry on success,
-C<undef> otherwise.
-
-=cut
-
-sub delete_entry
-{
-    my ($self,$idx) = @_;
-
-    if ($idx <= $#{$self->{time_table}})
-    {
-        $self->{entries_changed} = 1;
-        return splice @{$self->{time_table}},$idx,1;
-    }
-    else
-    {
-        return undef;
-    }
-}
-
-=item $cron->update_entry($idx,$entry)
-
-Updates the entry with index C<$idx>. C<$entry> is a hash ref as descibed in
-C<list_entries()> and must contain at least a value C<$entry->{time}>. If no
-C<$entry->{dispatcher}> is given, then the default dispatcher is used.  This
-method returns the old entry on success, C<undef> otherwise.
-
-=cut 
-
-sub update_entry
-{
-    my ($self,$idx,$entry) = @_;
-
-    die "No update entry given" unless $entry;
-    die "No time specification given" unless $entry->{time};
-    
-    if ($idx <= $#{$self->{time_table}})
-    {
-        my $new_entry = $self->deep_copy_entry($entry);
-        $new_entry->{dispatcher} = $self->{dispatcher} 
-          unless $new_entry->{dispatcher};
-        $new_entry->{args} = []
-          unless $new_entry->{args};
-        return splice @{$self->{time_table}},$idx,1,$new_entry;
-    }
-    else
-    {
-        return undef;
-    }
-}
-
-=item $cron->run([options])
-
-This method starts the scheduler.
-
-When called without options, this method will never return and executes the
-scheduled subroutine calls as needed.
-
-Alternatively, you can detach the main scheduler loop from the current process
-(daemon mode). In this case, the pid of the forked scheduler process will be
-returned.
-
-The C<options> parameter specifies the running mode of C<Schedule::Cron>.  It
-can be either a plain list which will be interpreted as a hash or it can be a
-reference to a hash. The following named parameters (keys of the provided hash)
-are recognized:
-
-=over
-
-=item   detach    
-
-If set to a true value the scheduler process is detached from the current
-process (UNIX only).
-
-=item  pid_file  
-
-If running in daemon mode, name the optional file, in which the process id of
-the scheduler process should be written. By default, no PID File will be
-created.
-
-=item nofork, skip, catch, log
-
-See C<new()> for a description of these configuration parameters, which can be
-provided here as well. Note, that the options given here overrides those of the
-constructor.
-
-=back
-
-
-Examples:
-
-   # Start  scheduler, detach  from current  process and
-   # write  the  PID  of  the forked  scheduler  to  the
-   # specified file
-   $cron->run(detach=>1,pid_file=>"/var/run/scheduler.pid");
-
-   # Start scheduler and wait forever.
-   $cron->run();
-
-=cut
-
-sub run 
-{ 
-    my $self = shift;
-    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
-    $cfg = { %{$self->{cfg}}, %$cfg }; # Merge in global config;
-
-    my $log = $cfg->{log};
-
-    $self->build_initial_queue;
-    delete $self->{entries_changed};
-    die "Nothing in schedule queue" unless @{$self->{queue}};
-    
-    # Install reaper now.
-    my $old_child_handler = $SIG{'CHLD'};
-    $SIG{'CHLD'} = sub {
-        &REAPER();
-        if ($old_child_handler && ref $old_child_handler eq 'CODE')
-        {
-            &$old_child_handler();
-        }
-    };
-
-    my $mainloop = sub 
-    {
-        while (42) 
-        {
-            my ($index,$time) = @{shift @{$self->{queue}}};
-            my $now = time;
-            my $sleep = 0;
-            if ($time < $now)
-            {
-                if ($cfg->{skip})
-                {
-                    $log->(0,"Schedule::Cron - Skipping job $index")
-                      if $log;
-                    $self->update_queue($index);
-                    next;
-                }
-            }
-            else
-            {
-                $sleep = $time - $now;
-            }
-            $0 = $self->get_process_prefix()." MainLoop - next: ".scalar(localtime($time));
-            die "No time found\n" unless $time;
-
-            dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")";
-            while ($sleep > 0) 
-            {
-                sleep($sleep);
-                $sleep = $time - time;
-            }
-
-            $self->execute($index,$cfg);
-
-            if ($self->{entries_changed}) {
-               dbg "rebuilding queue";
-               $self->build_initial_queue;
-               delete $self->{entries_changed};
-            } else {
-               $self->update_queue($index);
-            }
-        } 
-    };
-
-    if ($cfg->{detach}) 
-    {
-        defined(my $pid = fork) or die "Can't fork: $!";
-        if ($pid) 
-        {
-            # Parent:
-            if ($cfg->{pid_file}) 
-            {
-                if (open(P,">".$cfg->{pid_file})) 
-                {
-                    print P $pid,"\n";
-                    close P;
-                } 
-                else 
-                {
-                    warn "Warning: Cannot open ",$cfg->{pid_file}," : $!\n";
-                }
-                
-            }
-            return $pid;
-        } 
-        else 
-        {
-            # Child:
-            # Try to detach from terminal:
-            chdir '/';
-            open STDIN, '/dev/null' or die "Can't read /dev/null: $!";
-            open STDOUT, '>/dev/null' or die "Can't write to /dev/null: $!";
-            
-            eval { require POSIX; };
-            if ($@) 
-            {
-                #      if (1) {
-                if (open(T,"/dev/tty")) 
-                {
-                    dbg "No setsid found, trying ioctl() (Error: $@)";
-                    eval { require 'ioctl.ph'; };
-                    if ($@) 
-                    {
-                        eval { require 'sys/ioctl.ph'; };
-                        if ($@) 
-                        {
-                            die "No 'ioctl.ph'. Probably you have to run h2ph (Error: $@)";
-                        }
-                    }
-                    my $notty = &TIOCNOTTY;
-                    die "No TIOCNOTTY !" if $@ || !$notty;
-                    ioctl(T,$notty,0) || die "Cannot issue ioctl(..,TIOCNOTTY) : $!";
-                    close(T);
-                };
-            } 
-            else 
-            {
-                &POSIX::setsid() || die "Can't start a new session: $!";
-            }
-            open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
-            
-            $0 = $self->get_process_prefix()." MainLoop";
-            &$mainloop();
-        }
-    } 
-    else 
-    {
-        &$mainloop(); 
-    }
-}
-
-
-=item $cron->clean_timetable()
-
-Remove all scheduled entries
-
-=cut
-
-sub clean_timetable 
-{ 
-    my $self = shift;
-    $self->{entries_changed} = 1;
-    $self->{time_table} = [];
-}
-
-
-=item $cron->check_entry($id)
-
-Check, whether the given ID is already registered in the timetable. 
-A ID is the first argument in the argument parameter of the 
-a crontab entry.
-
-Returns (one of) the index in the  timetable (can be 0, too) if the ID
-could be found or C<undef> otherwise.
-
-Example:
-
-   $cron->add_entry("* * * * *","ROTATE");
-   .
-   .
-   defined($cron->check_entry("ROTATE")) || die "No ROTATE entry !"
-
-=cut 
-
-sub check_entry 
-{ 
-    my $self = shift;
-    my $id = shift;
-    return $self->{map}->{$id};
-}
-
-
-=item $cron->get_next_execution_time($cron_entry,[$ref_time])
-
-Well, this is mostly an internal method, but it might be useful on 
-its own. 
-
-The purpose of this method is to calculate the next execution time
-from a specified crontab entry
-
-Parameters:
-
-=over
-
-=item $cron_entry  
-
-The crontab entry as specified in L<"add_entry">
-
-=item $ref_time    
-
-The reference time for which the next time should be searched which matches
-C<$cron_entry>. By default, take the current time
-
-=back
-
-This method returns the number of epoch-seconds of the next matched 
-date for C<$cron_entry>.
-
-Since I suspect, that this calculation of the next execution time might
-fail in some circumstances (bugs are lurking everywhere ;-) an
-additional interactive method C<bug()> is provided for checking
-crontab entries against your expected output. Refer to the
-top-level README for additional usage information for this method.
-
-=cut
-
-sub get_next_execution_time 
-{ 
-  my $self = shift;
-  my $cron_entry = shift;
-  my $time = shift;
-  
-  $cron_entry = [ split /\s+/,$cron_entry ] unless ref($cron_entry);
-
-  # Expand and check entry:
-  # =======================
-  die "Exactly 5 or 6 columns has to be specified for a crontab entry ! (not ",
-    scalar(@$cron_entry),")"
-      if ($#$cron_entry != 4 && $#$cron_entry != 5);
-  
-  my @expanded;
-  my $w;
-  
-  for my $i (0..$#$cron_entry) 
-  {
-      my @e = split /,/,$cron_entry->[$i];
-      my @res;
-      my $t;
-      while (defined($t = shift @e)) {
-          # Subst "*/5" -> "0-59/5"
-          $t =~ s|^\*(/.+)$|$RANGES[$i][0]."-".$RANGES[$i][1].$1|e; 
-          
-          if ($t =~ m|^([^-]+)-([^-/]+)(/(.*))?$|) 
-          {
-              my ($low,$high,$step) = ($1,$2,$4);
-              $step = 1 unless $step;
-              if ($low !~ /^(\d+)/) 
-              {
-                  $low = $ALPHACONV[$i]{lc $low};
-              }
-              if ($high !~ /^(\d+)/) 
-              {
-                  $high = $ALPHACONV[$i]{lc $high};
-              }
-              if (! defined($low) || !defined($high) ||  $low > $high || $step !~ /^\d+$/) 
-              {
-                  die "Invalid cronentry '",$cron_entry->[$i],"'";
-              }
-              my $j;
-              for ($j = $low; $j <= $high; $j += $step) 
-              {
-                  push @e,$j;
-              }
-          } 
-          else 
-          {
-              $t = $ALPHACONV[$i]{lc $t} if $t !~ /^(\d+|\*)$/;
-              $t = $LOWMAP[$i]{$t} if exists($LOWMAP[$i]{$t});
-              
-              die "Invalid cronentry '",$cron_entry->[$i],"'" 
-                if (!defined($t) || ($t ne '*' && ($t < $RANGES[$i][0] || $t > $RANGES[$i][1])));
-              push @res,$t;
-          }
-      }
-      push @expanded, ($#res == 0 && $res[0] eq '*') ? [@res] : [ sort { $a <=> $b} @res];
-  }
-  
-  # Calculating time:
-  # =================
-  my $now = $time || time;
-
-  if ($expanded[2]->[0] ne '*' && $expanded[4]->[0] ne '*') 
-  {
-      # Special check for which time is lower (Month-day or Week-day spec):
-      my @bak = @{$expanded[4]};
-      $expanded[4] = [ '*' ];
-      my $t1 = $self->calc_time($now,\@expanded);
-      $expanded[4] = \@bak;
-      $expanded[2] = [ '*' ];
-      my $t2 = $self->calc_time($now,\@expanded);
-      dbg "MDay : ",scalar(localtime($t1))," -- WDay : ",scalar(localtime($t2));
-      return $t1 < $t2 ? $t1 : $t2;
-  } 
-  else 
-  {
-      # No conflicts possible:
-      return $self->calc_time($now,\@expanded);
-  }
-}
-
-# ==================================================
-# PRIVATE METHODS:
-# ==================================================
-
-# Build up executing queue and delete any
-# existing entries
-sub build_initial_queue 
-{ 
-    my $self = shift;
-    $self->{queue} = [ ];
-    #  dbg "TT: ",$#{$self->{time_table}};
-    for my $id (0..$#{$self->{time_table}}) 
-    {
-        $self->update_queue($id);
-    }
-}
-
-# deeply copy an entry in the time table
-sub deep_copy_entry
-{
-    my ($self,$entry) = @_;
-
-    my $args = [ @{$entry->{args}} ];
-    my $copied_entry = { %$entry };
-    $copied_entry->{args} = $args;
-    return $copied_entry;
-}
-
-# Execute a subroutine whose time has come
-sub execute 
-{ 
-  my $self = shift;
-  my $index = shift;
-  my $cfg = shift || $self->{cfg};
-  my $entry = $self->get_entry($index) 
-    || die "Internal: No entry with index $index found in ",Dumper([$self->list_entries()]);
-
-  my $pid;
-
-
-  my $log = $cfg->{log};
-
-  unless ($cfg->{nofork})
-  {
-      if ($pid = fork) 
-      {
-          # Parent
-          $log->(0,"Schedule::Cron - Forking child PID $pid") if $log;
-          # Register PID
-          $STARTEDCHILD{$pid} = 1;
-          return;
-      } 
-  }
-  
-  # Child
-  my $dispatch = $entry->{dispatcher};
-  die "No subroutine provided with $dispatch" 
-    unless ref($dispatch) eq "CODE";
-  my $args = $entry->{args};
-  
-  my @args = ();
-  if (defined($args) && defined($args->[0])) 
-  {
-      push @args,@$args;
-  }
-
-
-  my $args_label = @args ? "with (".join(",",$self->prepare_args(@args)).")" : "";
-  $0 = $self->get_process_prefix()." Dispatch $args_label"
-    unless $cfg->{nofork};
-  $log->(0,"Schedule::Cron - Starting job $index $args_label")
-    if $log;
-
-  if ($cfg->{catch})
-  {
-      # Evaluate dispatcher
-      eval
-      {
-          &$dispatch(@args);
-      };
-      if ($@)
-      {
-          $log->(2,"Schedule::Cron - Error within job $index: $@")
-            if $log;
-      }
-  }
-  else
-  {
-      # Let dispatcher die if needed.
-      &$dispatch(@args);
-  }
-
-  $log->(0,"Schedule::Cron - Finished job $index") if $log;
-  exit unless $cfg->{nofork};
-}
-
-# Udate the scheduler queue with a new entry
-sub update_queue 
-{ 
-    my $self = shift;
-    
-    my $index = shift;
-    
-    my $entry = $self->get_entry($index);
-    
-    my $new_time = $self->get_next_execution_time($entry->{time});
-    dbg "Updating Queue: ",scalar(localtime($new_time));
-    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
-    #  dbg "Queue now: ",Dumper($self->{queue});
-}
-
-
-# The heart of the module.
-# calulate the next concrete date
-# for execution from a cronta entry
-sub calc_time 
-{ 
-    my $self = shift;
-    my $now = shift;
-    my $expanded = shift;
-
-    my $offset = ($expanded->[5] ? 1 : 60);
-    my ($now_sec,$now_min,$now_hour,$now_mday,$now_mon,$now_wday,$now_year) = 
-      (localtime($now+$offset))[0,1,2,3,4,6,5];
-    $now_mon++; 
-    $now_year += 1900;
-
-    # Notes on variables set:
-    # $now_... : the current date, fixed at call time
-    # $dest_...: date used for backtracking. At the end, it contains
-    #            the desired lowest matching date
-    
-    my ($dest_mon,$dest_mday,$dest_wday,$dest_hour,$dest_min,$dest_sec,$dest_year) = 
-      ($now_mon,$now_mday,$now_wday,$now_hour,$now_min,$now_sec,$now_year);
-    
-    while ($dest_year <= $now_year + 1) 
-    { # Airbag...
-        dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday";
-        
-        
-        # Check month:
-        if ($expanded->[3]->[0] ne '*') 
-        {
-            unless (defined ($dest_mon = $self->get_nearest($dest_mon,$expanded->[3]))) 
-            {
-                $dest_mon = $expanded->[3]->[0];
-                $dest_year++;
-            } 
-        } 
-  
-        # Check for day of month:
-        if ($expanded->[2]->[0] ne '*') 
-        {           
-            if ($dest_mon != $now_mon) 
-            {      
-                $dest_mday = $expanded->[2]->[0];
-            } 
-            else 
-            {
-                unless (defined ($dest_mday = $self->get_nearest($dest_mday,$expanded->[2]))) 
-                {
-                    # Next day matched is within the next month. ==> redo it
-                    $dest_mday = $expanded->[2]->[0];
-                    $dest_mon++;
-                    if ($dest_mon > 12) 
-                    {
-                        $dest_mon = 1;
-                        $dest_year++;
-                    }
-                    dbg "Backtrack mday: $dest_mday/$dest_mon/$dest_year";
-                    next;
-                }
-            }
-        } 
-        else 
-        {
-            $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
-        }
-  
-        # Check for day of week:
-        if ($expanded->[4]->[0] ne '*') 
-        {
-            $dest_wday = $self->get_nearest($dest_wday,$expanded->[4]);
-            $dest_wday = $expanded->[4]->[0] unless $dest_wday;
-    
-            my ($mon,$mday,$year);
-            #      dbg "M: $dest_mon MD: $dest_mday WD: $dest_wday Y:$dest_year";
-            $dest_mday = 1 if $dest_mon != $now_mon;
-            my $t = parsedate(sprintf("%4.4d/%2.2d/%2.2d",$dest_year,$dest_mon,$dest_mday));
-            ($mon,$mday,$year) =  
-              (localtime(parsedate("$WDAYS[$dest_wday]",PREFER_FUTURE=>1,NOW=>$t-1)))[4,3,5]; 
-            $mon++;
-            $year += 1900;
-            
-            dbg "$mday/$mon/$year";
-            if ($mon != $dest_mon || $year != $dest_year) {
-                dbg "backtracking";
-                $dest_mon = $mon;
-                $dest_year = $year;
-                $dest_mday = 1;
-                $dest_wday = (localtime(parsedate(sprintf("%4.4d/%2.2d/%2.2d",
-                                                          $dest_year,$dest_mon,$dest_mday))))[6];
-                next;
-            }
-            
-            $dest_mday = $mday;
-        } 
-        else 
-        {
-            unless ($dest_mday) 
-            {
-                $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
-            }
-        }
-  
-        # Check for hour
-        if ($expanded->[1]->[0] ne '*') 
-        {
-            if ($dest_mday != $now_mday) 
-            {
-                $dest_hour = $expanded->[1]->[0];
-            } 
-            else 
-            {
-#       dbg "Checking for next hour $dest_hour";
-                unless (defined ($dest_hour = $self->get_nearest($dest_hour,$expanded->[1]))) 
-                {
-                    # Hour to match is at the next day ==> redo it
-                    $dest_hour = $expanded->[1]->[0];
-                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
-                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
-                    ($dest_mday,$dest_mon,$dest_year,$dest_wday) = 
-                      (localtime(parsedate("+ 1 day",NOW=>$t)))[3,4,5,6];
-                    $dest_mon++; 
-                    $dest_year += 1900;
-                    next; 
-                }
-            }
-        } 
-        else 
-        {
-            $dest_hour = ($dest_mday == $now_mday ? $dest_hour : 0);
-        }
-    
-        # Check for minute
-        if ($expanded->[0]->[0] ne '*') 
-        {
-            if ($dest_hour != $now_hour) 
-            {
-                $dest_min = $expanded->[0]->[0];
-            } 
-            else 
-            {
-                unless (defined ($dest_min = $self->get_nearest($dest_min,$expanded->[0]))) 
-                {
-                    # Minute to match is at the next hour ==> redo it
-                    $dest_min = $expanded->[0]->[0];
-                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
-                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
-                    ($dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
-                      (localtime(parsedate(" + 1 hour",NOW=>$t)))  [2,3,4,5,6];
-                    $dest_mon++;
-                    $dest_year += 1900;
-                    next;
-                }
-            }
-        } 
-        else 
-        {
-            $dest_min = ($dest_hour == $now_hour ? $dest_min : 0);
-        }
-
-        # Check for seconds
-        if ($expanded->[5])
-        {
-            if ($expanded->[5]->[0] ne '*')
-            {
-                if ($dest_min != $now_min) 
-                {
-                    $dest_sec = $expanded->[5]->[0];
-                } 
-                else 
-                {
-                    unless (defined ($dest_sec = $self->get_nearest($dest_sec,$expanded->[5]))) 
-                    {
-                        # Second to match is at the next minute ==> redo it
-                        $dest_sec = $expanded->[5]->[0];
-                        my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
-                                                  $dest_hour,$dest_min,$dest_sec,
-                                                  $dest_year,$dest_mon,$dest_mday));
-                        ($dest_min,$dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
-                          (localtime(parsedate(" + 1 minute",NOW=>$t)))  [1,2,3,4,5,6];
-                        $dest_mon++;
-                        $dest_year += 1900;
-                        next;
-                    }
-                }
-            } 
-            else 
-            {
-                $dest_sec = ($dest_min == $now_min ? $dest_sec : 0);
-            }
-        }
-        else
-        {
-            $dest_sec = 0;
-        }
-
-        
-        # We did it !!
-        my $date = sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
-                           $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday);
-        dbg "Next execution time: $date ",
-          $WDAYS[$dest_wday];
-        return parsedate($date);
-    }
-}
-
-# get next entry in list or 
-# undef if is the highest entry found
-sub get_nearest 
-{ 
-  my $self = shift;
-  my $x = shift;
-  my $to_check = shift;
-  foreach my $i (0 .. $#$to_check) 
-  {
-      if ($$to_check[$i] >= $x) 
-      {
-          return $$to_check[$i] ;
-      }
-  }
-  return undef;
-}
-
-
-# prepare a list of object for pretty printing e.g. in the process list
-sub prepare_args {
-    my $self = shift;
-    my @args = @_;
-    my @ret = ();
-    for my $arg (@args)
-    {
-        if (ref($arg) eq 'HASH') 
-        {
-            my $val = "{";
-            foreach my $key (keys %{$arg}) 
-            {
-                $val .= "$key=>".$args[0]->{$key}.", ";
-            }
-            if (length($val)>1)
-            {
-                chop $val; chop $val;
-            }
-            $val .= "}";
-            push @ret,$val;
-        } 
-        else
-        {
-            push @ret,$arg;
-        }         
-    }
-    return @ret;
-}
-
-# get the prefix to use when setting $0
-sub get_process_prefix { 
-    my $self = shift;
-    my $prefix = $self->{cfg}->{processprefix} || "Schedule::Cron";
-    return $prefix;
-}
-
-# our very own debugging routine
-# ('guess everybody has its own style ;-)
-sub dbg  
-{
-  if ($DEBUG) 
-  {
-      my $args = join('',@_) || "";
-      my $caller = (caller(1))[0];
-      my $line = (caller(0))[2];
-      $caller ||= $0;
-      if (length $caller > 22) 
-      {
-          $caller = substr($caller,0,10)."..".substr($caller,-10,10);
-      }
-      print STDERR sprintf ("%02d:%02d:%02d [%22.22s %4.4s]  %s\n",
-                            (localtime)[2,1,0],$caller,$line,$args);
-  }
-}
-
-# Helper method for reporting bugs concerning calculation
-# of execution bug:
-*bug = \&report_exectime_bug;   # Shortcut
-sub report_exectime_bug 
-{
-  my $self = shift;
-  my $endless = shift;
-  my $time = time;
-  my $inp;
-  my $now = $self->time_as_string($time);
-  my $email;
-
-  do 
-  {
-      while (1) 
-      {
-          $inp = $self->get_input("Reference time\n(default: $now)  : ");
-          if ($inp) 
-          {
-              parsedate($inp) || (print "Couldn't parse \"$inp\"\n",next);
-              $now = $inp;
-          }
-          last;
-      }
-      my $now_time = parsedate($now);
-    
-      my ($next_time,$next);
-      my @entries;
-      while (1) 
-      {
-          $inp = $self->get_input("Crontab time (5 columns)            : ");
-          @entries = split (/\s+/,$inp);
-          if (@entries != 5) 
-          {
-              print "Invalid crontab entry \"$inp\"\n";
-              next;
-          }
-          eval 
-          { 
-              local $SIG{ALRM} = sub {  die "TIMEOUT" };
-              alarm(60);
-              $next_time = Schedule::Cron->get_next_execution_time(\@entries,$now_time);
-              alarm(0);
-          };
-          if ($@) 
-          {
-              alarm(0);
-              if ($@ eq "TIMEOUT") 
-              {
-                  $next_time = -1;
-              } else 
-              {
-                  print "Invalid crontab entry \"$inp\" ($@)\n";
-                  next;
-              }
-          }
-        
-          if ($next_time > 0) 
-          {
-              $next = $self->time_as_string($next_time);
-          } else 
-          {
-              $next = "Run into infinite loop !!";
-          }
-          last;
-      }
-    
-      my ($expected,$expected_time);
-      while (1) 
-      {
-          $inp = $self->get_input("Expected time                       : ");
-          unless ($expected_time = parsedate($inp)) 
-          {
-              print "Couldn't parse \"$inp\"\n";
-              next;
-          } 
-          $expected = $self->time_as_string($expected_time);
-          last;
-      }
-    
-      # Print out bug report:
-      if ($expected eq $next) 
-      {
-          print "\nHmm, seems that everything's ok, or ?\n\n";
-          print "Calculated time: ",$next,"\n";
-          print "Expected time  : ",$expected,"\n";
-      } else 
-      {
-          print <<EOT;
-Congratulation, you hit a bug. 
-
-EOT
-          $email = $self->get_input("Your E-Mail Address (if available)  : ") 
-            unless defined($email);
-          $email = "" unless defined($email);
-      
-          print "\n","=" x 80,"\n";
-          print <<EOT;
-Please report the following lines
-to roland\@cpan.org
-
-EOT
-          print "# ","-" x 78,"\n";
-          print "Reftime: ",$now,"\n";
-          print "# Reported by : ",$email,"\n" if $email;
-          printf "%8s %8s %8s %8s %8s         %s\n",@entries,$expected;
-          print "# Calculated  : \n";
-          printf "# %8s %8s %8s %8s %8s         %s\n",@entries,$next;
-          unless ($endless) 
-          {
-              require Config;
-              my $vers = `uname -r 2>/dev/null` || $Config::Config{'osvers'} ;
-              chomp $vers;
-              my $osname = `uname -s 2>/dev/null` || $Config::Config{'osname'};
-              chomp $osname;
-              print "# OS: $osname ($vers)\n";
-              print "# Perl-Version: $]\n";
-              print "# Time::ParseDate-Version: ",$Time::ParseDate::VERSION,"\n";
-          }
-          print "# ","-" x 78,"\n";
-      }
-    
-      print "\n","=" x 80,"\n";
-  } while ($endless);
-}
-
-my ($input_initialized,$term);
-sub get_input 
-{ 
-  my $self = shift;
-  my $prompt = shift;
-  use vars qw($term);
-
-  unless (defined($input_initialized)) 
-  {
-      eval { require Term::ReadLine; };
-    
-      $input_initialized = $@ ? 0 : 1;
-      if ($input_initialized) 
-      {
-          $term = new Term::ReadLine;
-          $term->ornaments(0);
-      }
-  }
-  
-  unless ($input_initialized) 
-  {
-      print $prompt;
-      my $inp = <STDIN>;
-      chomp $inp;
-      return $inp;
-  } 
-  else 
-  {
-      chomp $prompt;
-      my @prompt = split /\n/s,$prompt;
-      if ($#prompt > 0)
-      {
-          print join "\n",@prompt[0..$#prompt-1],"\n";
-      }
-      my $inp = $term->readline($prompt[$#prompt]);
-      return $inp;
-  }
-}
-
-sub time_as_string 
-{ 
-  my $self = shift;
-  my $time = shift; 
-
-  my ($min,$hour,$mday,$month,$year,$wday) = (localtime($time))[1..6];
-  $month++;
-  $year += 1900;
-  $wday = $WDAYS[$wday];
-  return sprintf("%2.2d:%2.2d %2.2d/%2.2d/%4.4d %s",
-                 $hour,$min,$mday,$month,$year,$wday);
-}
-
-=back
-
-=head1 TODO
-
-=over 
-
-=item *
-
-Provide a C<reload()> method for reexaming the crontab file 
-
-=back
-
-
-=head1 COPYRIGHT
-
-Copyright 1999-2006 Roland Huss.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=head1 AUTHOR
-
-                                                    ...roland
-
-=cut
-
-1;
-
-
-
-
diff --git a/MANIFEST b/MANIFEST
index 6047947..2f8ba91 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,15 +1,21 @@
 ChangeLog
 CHANGES
-Cron.pm
+lib/Schedule/Cron.pm
 Makefile.PL
+Build.PL
 MANIFEST			This list of files
 META.yml
 README
+t/after_job.t
 t/callbackreschedule.t
 t/entry.t
 t/execution_time.t
+t/kwalitee.t
 t/load_crontab.t
 t/nofork.t
+t/pod.t
+t/pod_coverage.t
+t/pretty_print_args.t
 t/sighandler.t
 t/startup.t
 t/test.crontab
diff --git a/META.yml b/META.yml
index bd09c6a..6852f9c 100644
--- a/META.yml
+++ b/META.yml
@@ -1,11 +1,31 @@
-# http://module-build.sourceforge.net/META-spec.html
-#XXXXXXX This is a prototype!!!  It will change in the future!!! XXXXX#
-name:         Schedule-Cron
-version:      0.97
-version_from: Cron.pm
-installdirs:  site
+---
+name: Schedule-Cron
+version: 0.98_01
+author:
+  - Roland Huss (roland@cpan.org)
+abstract: cron-like scheduler for Perl subroutines
+license: perl
+resources:
+  license: http://dev.perl.org/licenses/
 requires:
-    Time::ParseDate:               99.00
-
-distribution_type: module
-generated_by: ExtUtils::MakeMaker version 6.30
+  Data::Dumper: 0
+  Time::ParseDate: 99.00
+build_requires:
+  Test: 0
+  Test::More: 0
+recommends:
+  Module::Build: 0
+  ioctl.ph: 0
+  sys::ioctl.ph: 0
+provides:
+  Schedule::Cron:
+    file: lib/Schedule/Cron.pm
+    version: 0.98_01
+generated_by: Module::Build version 0.31012
+keywords:
+    - Cron
+    - Scheduler
+    - Job
+meta-spec:
+  url: http://module-build.sourceforge.net/META-spec-v1.2.html
+  version: 1.2
diff --git a/Makefile.PL b/Makefile.PL
index a1c9fb6..de5f8ab 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,12 +1,15 @@
 use ExtUtils::MakeMaker;
 WriteMakefile
   (
+   NO_META => 1,
    NAME => "Schedule::Cron",
-   VERSION_FROM => "Cron.pm",
+   VERSION_FROM => "lib/Schedule/Cron.pm",
    ($] >= 5.005
-      ? (ABSTRACT   => 'cron-like scheduler',
-         AUTHOR     => 'Roland Huss (roland@consol.de)')
-      : ()),
-   PREREQ_PM => { "Time::ParseDate" => '99.00'},
+    ? (ABSTRACT   => 'Cron-like scheduler for Perl subroutines',
+         AUTHOR     => 'Roland Huss (roland@cpan.org)')
+    : ()),
+   ($ExtUtils::MakeMaker::VERSION >= 6.3002 ?
+    ('LICENSE'		=> 'perl', ) : ()),
+   PREREQ_PM => { "Time::ParseDate" => '99.00',"Data::Dumper" => 0},
    'dist' => {COMPRESS=>'gzip',SUFFIX=>'gz'}
   );
diff --git a/README b/README
index f001a1c..34734ca 100644
--- a/README
+++ b/README
@@ -136,10 +136,10 @@ execution date  (relative to  the reference time).   The dates  can be
 specified in  a format understood by  'parsedate' from Time::ParseDate
 (like 'now  + 5  days').  Please include  the output of  this command.
 
-COPYRIGHT
----------
+LICENSE
+-------
 
-Copyright 1999-2006 Roland Huss.
+Copyright 1999-2009 Roland Huss.
 
 This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
new file mode 100644
index 0000000..c66101c
--- /dev/null
+++ b/lib/Schedule/Cron.pm
@@ -0,0 +1,1605 @@
+#!/usr/bin/perl -w
+
+# $Id: Cron.pm,v 1.16 2006/11/27 13:42:52 roland Exp $
+
+=head1 NAME
+
+Cron - cron-like scheduler for Perl subroutines
+
+=head1 SYNOPSIS
+
+  use Schedule::Cron;
+
+  # Subroutines to be called
+  sub dispatcher { 
+    print "ID:   ",shift,"\n"; 
+    print "Args: ","@_","\n";
+  }
+
+  sub check_links { 
+    # do something... 
+  }
+
+  # Create new object with default dispatcher
+  my $cron = new Schedule::Cron(\&dispatcher);
+
+  # Load a crontab file
+  $cron->load_crontab("/var/spool/cron/perl");
+
+  # Add dynamically  crontab entries
+  $cron->add_entry("3 4  * * *",ROTATE => "apache","sendmail");
+  $cron->add_entry("0 11 * * Mon-Fri",\&check_links);
+
+  # Run scheduler 
+  $cron->run(detach=>1);
+                   
+
+=head1 DESCRIPTION
+
+This module provides a simple but complete cron like scheduler.  I.e this
+modules can be used for periodically executing Perl subroutines.  The dates and
+parameters for the subroutines to be called are specified with a format known
+as crontab entry (see L<"METHODS">, C<add_entry()> and L<crontab(5)>)
+
+The philosophy behind C<Schedule::Cron> is to call subroutines periodically
+from within one single Perl program instead of letting C<cron> trigger several
+(possibly different) perl scripts. Everything under one roof.  Furthermore
+C<Schedule::Cron> provides mechanism to create crontab entries dynamically,
+which isn't that easy with C<cron>.
+
+C<Schedule::Cron> knows about all extensions (well, at least all extensions I'm
+aware of, i.e those of the so called "Vixie" cron) for crontab entries like
+ranges including 'steps', specification of month and days of the week by name
+or coexistence of lists and ranges in the same field.  And even a bit more
+(like lists and ranges with symbolic names).
+
+=head1 METHODS
+
+=over 4
+
+=cut
+
+#'
+
+package Schedule::Cron;
+
+use Time::ParseDate;
+use Data::Dumper;
+
+use strict;
+use vars qw($VERSION  $DEBUG);
+use subs qw(dbg);
+
+my $HAS_POSIX;
+
+BEGIN {
+  eval { 
+    require POSIX;
+    import POSIX ":sys_wait_h";
+  };
+  $HAS_POSIX = $@ ? 0 : 1;
+}
+
+
+$VERSION = "0.98_01";
+
+our $DEBUG = 0;
+my %STARTEDCHILD = ();
+
+my @WDAYS = qw(
+                 Sunday
+                 Monday
+                 Tuesday
+                 Wednesday
+                 Thursday
+                 Friday
+                 Saturday
+                 Sunday
+                );
+
+my @ALPHACONV = (
+                 { },
+                 { },
+                 { },
+                 { qw(jan 1 feb 2 mar 3 apr 4 may 5 jun 6 jul 7 aug 8
+                      sep 9 oct 10 nov 11 dec 12) },
+                 { qw(sun 0 mon 1 tue 2 wed 3 thu 4 fri 5 sat 6)},
+                 {  }
+                );
+my @RANGES = ( 
+              [ 0,59 ],
+              [ 0,23 ],
+              [ 0,31 ],
+              [ 0,12 ],
+              [ 0,7  ],
+              [ 0,60 ]
+             );
+
+my @LOWMAP = ( 
+              {},
+              {},
+              { 0 => 1},
+              { 0 => 1},
+              { 7 => 0},
+              {},
+             );
+
+sub REAPER {
+    if ($HAS_POSIX)
+    {
+        # Only on platforms supporting POSIX semantisc
+        foreach my $pid (keys %STARTEDCHILD) {
+            my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
+            if ($res > 0) {
+                # We reaped a truly running process
+                delete $STARTEDCHILD{$pid};
+            }
+        }
+    } 
+    else
+    {
+        my $waitedpid = 0;
+        while($waitedpid != -1) {
+            $waitedpid = wait;
+        }
+    }
+}
+
+=item $cron = new Schedule::Cron($dispatcher,[extra args])
+
+Creates a new C<Cron> object.  C<$dispatcher> is a reference to a subroutine,
+which will be called by default.  C<$dispatcher> will be invoked with the
+arguments parameter provided in the crontab entry if no other subroutine is
+specified. This can be either a single argument containing the argument
+parameter literally has string (default behavior) or a list of arguments when
+using the C<eval> option described below.
+
+The date specifications must be either provided via a crontab like file or
+added explicitly with C<add_entry()> (L<"add_entry">).
+
+I<extra_args> can be a hash or hash reference for additional arguments.  The
+following parameters are recognized:
+
+=over
+
+=item file => <crontab>  
+
+
+Load the crontab entries from <crontab>
+
+=item eval =>  1
+
+Eval the argument parameter in a crontab entry before calling the subroutine
+(instead of literally calling the dispatcher with the argument parameter as
+string)
+
+=item nofork => 1
+
+Don't fork when starting the scheduler. Instead, the jobs are executed within
+current process. In your executed jobs, you have full access to the global
+variables of your script and hence might influence other jobs running at a
+different time. This behaviour is fundamentally different to the 'fork' mode,
+where each jobs gets its own process and hence a B<copy> of the process space,
+independent of each other job and the main process. This is due to the nature
+of the  C<fork> system call. 
+
+=item skip => 1
+
+Skip any pending jobs whose time has passed. This option is only useful in
+combination with C<nofork> where a job might block the execution of the
+following jobs for quite some time. By default, any pending job is executed
+even if its scheduled execution time has already passed. With this option set
+to true all pending which would have been started in the meantime are skipped. 
+
+=item catch => 1
+
+Catch any exception raised by a job. This is especially useful in combination with
+the C<nofork> option to avoid stopping the main process when a job raises an
+exception (dies).
+
+=item after_job => \&after_sub
+
+Call a subroutine after a job has been run. The first argument is the return
+value of the dispatched job, the reminding arguments are the arguments with
+which the dispatched job has been called.
+
+Example:
+
+   my $cron = new Schedule::Cron(..., after_job => sub {
+          my ($ret,@args) = @_;
+          print "Return value: ",$ret," - job arguments: (",join ":",@args,")\n";
+   });
+
+=item log => \&log_sub
+
+Install a logging subroutine. The given subroutine is called for several events
+during the lifetime of a job. This method is called with two arguments: A log
+level of 0 (info),1 (warning) or 2 (error) depending on the importance of the
+message and the message itself.
+
+For example, you could use I<Log4perl> (L<http://log4perl.sf.net>) for logging
+purposes for example like in the following code snippet:
+
+   use Log::Log4perl;
+   use Log::Log4perl::Level;
+
+   my $log_method = sub {
+      my ($level,$msg) = @_;
+      my $DBG_MAP = { 0 => $INFO, 1 => $WARN, 2 => $ERROR };
+
+      my $logger = Log::Log4perl->get_logger("My::Package");
+      $logger->log($DBG_MAP->{$level},$msg);
+   }
+  
+   my $cron = new Schedule::Cron(.... , log => $log_method);
+
+=item processprefix => <name>
+
+Cron::Schedule sets the process' name (i.e. C<$0>) to contain some informative
+messages like when the next job executes or with which arguments a job is
+called. By default, the prefix for this labels is C<Schedule::Cron>. With this
+option you can set it to something different. You can e.g. use C<$0> to include
+the original process name.
+
+=back
+
+=cut
+
+sub new 
+{
+    my $class = shift;
+    my $dispatcher = shift || die "No dispatching sub provided";
+    die "Dispatcher not a ref to a subroutine" unless ref($dispatcher) eq "CODE";
+    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
+    $cfg->{processprefix} = "Schedule::Cron" unless $cfg->{processprefix};
+    my $self = { 
+                cfg => $cfg,
+                dispatcher => $dispatcher,
+                queue => [ ],
+                map => { }
+             };
+    bless $self,(ref($class) || $class);
+    
+    $self->load_crontab if $cfg->{file};
+    $self;
+}
+
+=item $cron->load_crontab($file)
+
+=item $cron->load_crontab(file=>$file,[eval=>1])
+
+Loads and parses the crontab file C<$file>. The entries found in this file will
+be B<added> to the current time table with C<$cron-E<gt>add_entry>.
+
+The format of the file consists of cron commands containing of lines with at
+least 5 columns, whereas the first 5 columns specify the date.  The rest of the
+line (i.e columns 6 and greater) contains the argument with which the
+dispatcher subroutine will be called.  By default, the dispatcher will be
+called with one single string argument containing the rest of the line
+literally.  Alternatively, if you call this method with the optional argument
+C<eval=E<gt>1> (you must then use the second format shown above), the rest of
+the line will be evaled before used as argument for the dispatcher.
+
+For the format of the first 5 columns, please see L<"add_entry">.
+
+Blank lines and lines starting with a C<#> will be ignored. 
+
+There's no way to specify another subroutine within the crontab file.  All
+calls will be made to the dispatcher provided at construction time.
+
+If    you   want    to    start   up    fresh,    you   should    call
+C<$cron-E<gt>clean_timetable()> before.
+
+Example of a crontab fiqw(le:)
+
+   # The following line runs on every Monday at 2:34 am
+   34 2 * * Mon  "make_stats"
+   # The next line should be best read in with an eval=>1 argument
+   *  * 1 1 *    { NEW_YEAR => '1',HEADACHE => 'on' }
+
+=cut
+
+#'
+
+sub load_crontab 
+{
+  my $self = shift;
+  my $cfg = shift;
+
+  if ($cfg) 
+  {
+      if (@_) 
+      {
+          $cfg = ref($cfg) eq "HASH" ? $cfg : { $cfg,@_ };
+      } 
+      elsif (!ref($cfg)) 
+      {
+          my $new_cfg = { };
+          $new_cfg->{file} = $cfg;
+          $cfg = $new_cfg;
+      }
+  }
+  
+  my $file = $cfg->{file} || $self->{cfg}->{file} || die "No filename provided";
+  my $eval = $cfg->{eval} || $self->{cfg}->{eval};
+  
+  open(F,$file) || die "Cannot open schedule $file : $!";
+  my $line = 0;
+  while (<F>) 
+  {
+      $line++;
+      next if /^$/;
+      next if /^\s*#/;
+      chomp;
+      s/\s*(.*)\s*$/$1/;
+      my ($min,$hour,$dmon,$month,$dweek,$rest) = split (/\s+/,$_,6);
+      
+      my $time = [ $min,$hour,$dmon,$month,$dweek ];
+
+      # Try to check, whether an optional 6th column specifying seconds 
+      # exists: 
+      my $args;
+      if ($rest)
+      {
+          my ($col6,$more_args) = split(/\s+/,$rest,2);
+          if ($col6 =~ /^[\d\-\*\,\/]+$/)
+          {
+              push @$time,$col6;
+              dbg "M: $more_args";
+              $args = $more_args;
+          }
+          else
+          {
+              $args = $rest;
+          }
+      }
+      $self->add_entry($time,{ 'args' => $args, 'eval' => $eval});
+  }
+  close F;
+}
+
+=item $cron->add_entry($timespec,[arguments])
+
+Adds a new entry to the list of scheduled cron jobs.
+
+B<Time and Date specification>
+
+C<$timespec> is the specification of the scheduled time in crontab format
+(L<crontab(5)>) which contains five mandatory time and date fields and an
+optional 6th column. C<$timespec> can be either a plain string, which contains
+a whitespace separated time and date specification.  Alternatively,
+C<$timespec> can be a reference to an array containing the five elements for
+the date fields.
+
+The time and date fields are (taken mostly from L<crontab(5)>, "Vixie" cron): 
+
+   field          values
+   =====          ======
+   minute         0-59
+   hour           0-23
+   day of month   1-31 
+   month          1-12 (or as names)
+   day of week    0-7 (0 or 7 is Sunday, or as names )
+   seconds        0-59 (optional)
+
+ A field may be an asterisk (*), which always stands for
+ ``first-last''.
+
+ Ranges of numbers are  allowed.  Ranges are two numbers
+ separated  with  a  hyphen.   The  specified  range  is
+ inclusive.   For example, 8-11  for an  ``hours'' entry
+ specifies execution at hours 8, 9, 10 and 11.
+
+ Lists  are allowed.   A list  is a  set of  numbers (or
+ ranges)  separated by  commas.   Examples: ``1,2,5,9'',
+ ``0-4,8-12''.
+
+ Step  values can  be used  in conjunction  with ranges.
+ Following a range with ``/<number>'' specifies skips of
+ the  numbers value  through the  range.   For example,
+ ``0-23/2'' can  be used in  the hours field  to specify
+ command execution every  other hour (the alternative in
+ the V7 standard is ``0,2,4,6,8,10,12,14,16,18,20,22'').
+ Steps are  also permitted after an asterisk,  so if you
+ want to say ``every two hours'', just use ``*/2''.
+
+ Names can also  be used for the ``month''  and ``day of
+ week''  fields.  Use  the  first three  letters of  the
+ particular day or month (case doesn't matter).
+
+ Note: The day of a command's execution can be specified
+       by two fields  -- day of month, and  day of week.
+       If both fields are restricted (ie, aren't *), the
+       command will be run when either field matches the
+       current  time.  For  example, ``30  4 1,15  * 5''
+       would cause a command to be run at 4:30 am on the
+       1st and 15th of each month, plus every Friday
+
+Examples:
+
+ "8  0 * * *"         ==> 8 minutes after midnight, every day
+ "5 11 * * Sat,Sun"   ==> at 11:05 on each Saturday and Sunday
+ "0-59/5 * * * *"     ==> every five minutes
+ "42 12 3 Feb Sat"    ==> at 12:42 on 3rd of February and on 
+                          each Saturday in February
+ "32 11 * * * 0-30/2" ==> 11:32:00, 11:32:02, ... 11:32:30 every 
+                          day
+
+In addition, ranges or lists of names are allowed. 
+
+An optional sixth column can be used to specify the seconds within the
+minute. If not present, it is implicitely set to "0".
+
+B<Command specification>
+
+The subroutine to be executed when the the C<$timespec> matches can be
+specified in several ways.
+
+First, if the optional C<arguments> are lacking, the default dispatching
+subroutine provided at construction time will be called without arguments.
+
+If the second parameter to this method is a reference to a subroutine, this
+subroutine will be used instead of the dispatcher.
+
+Any additional parameters will be given as arguments to the subroutine to be
+executed.  You can also specify a reference to an array instead of a list of
+parameters.
+
+You can also use a named parameter list provided as an hashref.  The named
+parameters recognized are:
+
+=over
+
+=item subroutine      
+
+=item sub 
+
+Reference to subroutine to be executed
+
+=item arguments
+
+=item args
+
+Reference to array containing arguments to be use when calling the subroutine
+
+=item eval
+
+If true, use the evaled string provided with the C<arguments> parameter.  The
+evaluation will take place immediately (not when the subroutine is going to be
+called)
+
+=back
+
+Examples:
+
+   $cron->add_entry("* * * * *");
+   $cron->add_entry("* * * * *","doit");
+   $cron->add_entry("* * * * *",\&dispatch,"first",2,"third");
+   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
+                                 'arguments'  => [ "first",2,"third" ]});
+   $cron->add_entry("* * * * *",{'subroutine' => \&dispatch,
+                                 'arguments'  => '[ "first",2,"third" ]',
+                                 'eval'       => 1});
+
+=cut 
+
+sub add_entry 
+{ 
+    my $self = shift;
+    my $time = shift;
+    my $args = shift || []; 
+    my $dispatch;
+    
+    #  dbg "Args: ",Dumper($time,$args);
+    
+    if (ref($args) eq "HASH") 
+    {
+        my $cfg = $args;
+        $args = undef;
+        $dispatch = $cfg->{subroutine} || $cfg->{sub};
+        $args = $cfg->{arguments} || $cfg->{args} || [];
+        if ($cfg->{eval} && $cfg) 
+        {
+            die "You have to provide a simple scalar if using eval" if (ref($args));
+            my $orig_args = $args;
+            dbg "Evaled args ",Dumper($args);
+            $args = [ eval $args ];
+            die "Cannot evaluate args (\"$orig_args\")"
+              if $@;
+        }
+    } 
+    elsif (ref($args) eq "CODE") 
+    {
+        $dispatch = $args;
+        $args = shift || [];
+    }
+    if (ref($args) ne "ARRAY") 
+    {
+        $args = [ $args,@_ ];
+    }
+
+    $dispatch ||= $self->{dispatcher};
+
+
+    my $time_array = ref($time) ? $time : [ split(/\s+/,$time) ];
+    die "Invalid number of columns in time entry (5 or 6)\n"
+      if ($#$time_array != 4 && $#$time_array !=5);
+    $time = join ' ',@$time_array;
+
+    #  dbg "Adding ",Dumper($time);
+    push @{$self->{time_table}},
+    {
+     time => $time,
+     dispatcher => $dispatch,
+     args => $args
+    };
+    
+    $self->{entries_changed} = 1;
+    #  dbg "Added Args ",Dumper($self->{args});
+    
+    my $index = $#{$self->{time_table}};
+    my $id = $args->[0];
+    $self->{map}->{$id} = $index if $id;
+    
+    return $#{$self->{time_table}};
+}
+
+=item @entries = $cron->list_entries()
+
+Return a list of cron entries. Each entry is a hash reference of the following
+form:
+
+  $entry = { 
+             time => $timespec,
+             dispatch => $dispatcher,
+             args => $args_ref
+           }
+
+Here C<$timespec> is the specified time in crontab format as provided to
+C<add_entry>, C<$dispatcher> is a reference to the dispatcher for this entry
+and C<$args_ref> is a reference to an array holding additional arguments (which
+can be an empty array reference). For further explanation of this arguments
+refer to the documentation of the method C<add_entry>.
+
+The order index of each entry can be used within C<update_entry>, C<get_entry>
+and C<delete_entry>. But be aware, when you are deleting an entry, that you
+have to refetch the list, since the order will have changed.
+
+Note that these entries are returned by value and were opbtained from the
+internal list by a deep copy. I.e. you are free to modify it, but this won't
+influence the original entries. Instead use C<update_entry> if you need to
+modify an exisiting crontab entry.
+
+=cut
+
+sub list_entries
+{
+    my ($self) = shift;
+    
+    my @ret;
+    foreach my $entry (@{$self->{time_table}})
+    {
+        # Deep copy $entry
+        push @ret,$self->_deep_copy_entry($entry);
+    }
+    return @ret;
+}
+
+
+=item $entry = $cron->get_entry($idx)
+
+Get a single entry. C<$entry> is either a hashref with the possible keys
+C<time>, C<dispatch> and C<args> (see C<list_entries()>) or undef if no entry
+with the given index C<$idx> exists.
+
+=cut
+
+sub get_entry
+{
+    my ($self,$idx) = @_;
+
+    my $entry = $self->{time_table}->[$idx];
+    if ($entry)
+    {
+        return $self->_deep_copy_entry($entry);
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->delete_entry($idx)
+
+Delete the entry at index C<$idx>. Returns the deleted entry on success,
+C<undef> otherwise.
+
+=cut
+
+sub delete_entry
+{
+    my ($self,$idx) = @_;
+
+    if ($idx <= $#{$self->{time_table}})
+    {
+        $self->{entries_changed} = 1;
+        return splice @{$self->{time_table}},$idx,1;
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->update_entry($idx,$entry)
+
+Updates the entry with index C<$idx>. C<$entry> is a hash ref as descibed in
+C<list_entries()> and must contain at least a value C<$entry->{time}>. If no
+C<$entry->{dispatcher}> is given, then the default dispatcher is used.  This
+method returns the old entry on success, C<undef> otherwise.
+
+=cut 
+
+sub update_entry
+{
+    my ($self,$idx,$entry) = @_;
+
+    die "No update entry given" unless $entry;
+    die "No time specification given" unless $entry->{time};
+    
+    if ($idx <= $#{$self->{time_table}})
+    {
+        my $new_entry = $self->_deep_copy_entry($entry);
+        $new_entry->{dispatcher} = $self->{dispatcher} 
+          unless $new_entry->{dispatcher};
+        $new_entry->{args} = []
+          unless $new_entry->{args};
+        return splice @{$self->{time_table}},$idx,1,$new_entry;
+    }
+    else
+    {
+        return undef;
+    }
+}
+
+=item $cron->run([options])
+
+This method starts the scheduler.
+
+When called without options, this method will never return and executes the
+scheduled subroutine calls as needed.
+
+Alternatively, you can detach the main scheduler loop from the current process
+(daemon mode). In this case, the pid of the forked scheduler process will be
+returned.
+
+The C<options> parameter specifies the running mode of C<Schedule::Cron>.  It
+can be either a plain list which will be interpreted as a hash or it can be a
+reference to a hash. The following named parameters (keys of the provided hash)
+are recognized:
+
+=over
+
+=item   detach    
+
+If set to a true value the scheduler process is detached from the current
+process (UNIX only).
+
+=item  pid_file  
+
+If running in daemon mode, name the optional file, in which the process id of
+the scheduler process should be written. By default, no PID File will be
+created.
+
+=item nofork, skip, catch, log
+
+See C<new()> for a description of these configuration parameters, which can be
+provided here as well. Note, that the options given here overrides those of the
+constructor.
+
+=back
+
+
+Examples:
+
+   # Start  scheduler, detach  from current  process and
+   # write  the  PID  of  the forked  scheduler  to  the
+   # specified file
+   $cron->run(detach=>1,pid_file=>"/var/run/scheduler.pid");
+
+   # Start scheduler and wait forever.
+   $cron->run();
+
+=cut
+
+sub run 
+{ 
+    my $self = shift;
+    my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
+    $cfg = { %{$self->{cfg}}, %$cfg }; # Merge in global config;
+
+    my $log = $cfg->{log};
+
+    $self->_build_initial_queue;
+    delete $self->{entries_changed};
+    die "Nothing in schedule queue" unless @{$self->{queue}};
+    
+    # Install reaper now.
+    my $old_child_handler = $SIG{'CHLD'};
+    $SIG{'CHLD'} = sub {
+        &REAPER();
+        if ($old_child_handler && ref $old_child_handler eq 'CODE')
+        {
+            &$old_child_handler();
+        }
+    };
+
+    my $mainloop = sub 
+    {
+        while (42) 
+        {
+            my ($index,$time) = @{shift @{$self->{queue}}};
+            my $now = time;
+            my $sleep = 0;
+            if ($time < $now)
+            {
+                if ($cfg->{skip})
+                {
+                    $log->(0,"Schedule::Cron - Skipping job $index")
+                      if $log;
+                    $self->_update_queue($index);
+                    next;
+                }
+            }
+            else
+            {
+                $sleep = $time - $now;
+            }
+            $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time));
+            die "No time found\n" unless $time;
+
+            dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")";
+            while ($sleep > 0) 
+            {
+                sleep($sleep);
+                $sleep = $time - time;
+            }
+
+            $self->_execute($index,$cfg);
+
+            if ($self->{entries_changed}) {
+               dbg "rebuilding queue";
+               $self->_build_initial_queue;
+               delete $self->{entries_changed};
+            } else {
+               $self->_update_queue($index);
+            }
+        } 
+    };
+
+    if ($cfg->{detach}) 
+    {
+        defined(my $pid = fork) or die "Can't fork: $!";
+        if ($pid) 
+        {
+            # Parent:
+            if ($cfg->{pid_file}) 
+            {
+                if (open(P,">".$cfg->{pid_file})) 
+                {
+                    print P $pid,"\n";
+                    close P;
+                } 
+                else 
+                {
+                    warn "Warning: Cannot open ",$cfg->{pid_file}," : $!\n";
+                }
+                
+            }
+            return $pid;
+        } 
+        else 
+        {
+            # Child:
+            # Try to detach from terminal:
+            chdir '/';
+            open STDIN, '/dev/null' or die "Can't read /dev/null: $!";
+            open STDOUT, '>/dev/null' or die "Can't write to /dev/null: $!";
+            
+            eval { require POSIX; };
+            if ($@) 
+            {
+                #      if (1) {
+                if (open(T,"/dev/tty")) 
+                {
+                    dbg "No setsid found, trying ioctl() (Error: $@)";
+                    eval { require 'ioctl.ph'; };
+                    if ($@) 
+                    {
+                        eval { require 'sys/ioctl.ph'; };
+                        if ($@) 
+                        {
+                            die "No 'ioctl.ph'. Probably you have to run h2ph (Error: $@)";
+                        }
+                    }
+                    my $notty = &TIOCNOTTY;
+                    die "No TIOCNOTTY !" if $@ || !$notty;
+                    ioctl(T,$notty,0) || die "Cannot issue ioctl(..,TIOCNOTTY) : $!";
+                    close(T);
+                };
+            } 
+            else 
+            {
+                &POSIX::setsid() || die "Can't start a new session: $!";
+            }
+            open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
+            
+            $0 = $self->_get_process_prefix()." MainLoop";
+            &$mainloop();
+        }
+    } 
+    else 
+    {
+        &$mainloop(); 
+    }
+}
+
+
+=item $cron->clean_timetable()
+
+Remove all scheduled entries
+
+=cut
+
+sub clean_timetable 
+{ 
+    my $self = shift;
+    $self->{entries_changed} = 1;
+    $self->{time_table} = [];
+}
+
+
+=item $cron->check_entry($id)
+
+Check, whether the given ID is already registered in the timetable. 
+A ID is the first argument in the argument parameter of the 
+a crontab entry.
+
+Returns (one of) the index in the  timetable (can be 0, too) if the ID
+could be found or C<undef> otherwise.
+
+Example:
+
+   $cron->add_entry("* * * * *","ROTATE");
+   .
+   .
+   defined($cron->check_entry("ROTATE")) || die "No ROTATE entry !"
+
+=cut 
+
+sub check_entry 
+{ 
+    my $self = shift;
+    my $id = shift;
+    return $self->{map}->{$id};
+}
+
+
+=item $cron->get_next_execution_time($cron_entry,[$ref_time])
+
+Well, this is mostly an internal method, but it might be useful on 
+its own. 
+
+The purpose of this method is to calculate the next execution time
+from a specified crontab entry
+
+Parameters:
+
+=over
+
+=item $cron_entry  
+
+The crontab entry as specified in L<"add_entry">
+
+=item $ref_time    
+
+The reference time for which the next time should be searched which matches
+C<$cron_entry>. By default, take the current time
+
+=back
+
+This method returns the number of epoch-seconds of the next matched 
+date for C<$cron_entry>.
+
+Since I suspect, that this calculation of the next execution time might
+fail in some circumstances (bugs are lurking everywhere ;-) an
+additional interactive method C<bug()> is provided for checking
+crontab entries against your expected output. Refer to the
+top-level README for additional usage information for this method.
+
+=cut
+
+sub get_next_execution_time 
+{ 
+  my $self = shift;
+  my $cron_entry = shift;
+  my $time = shift;
+  
+  $cron_entry = [ split /\s+/,$cron_entry ] unless ref($cron_entry);
+
+  # Expand and check entry:
+  # =======================
+  die "Exactly 5 or 6 columns has to be specified for a crontab entry ! (not ",
+    scalar(@$cron_entry),")"
+      if ($#$cron_entry != 4 && $#$cron_entry != 5);
+  
+  my @expanded;
+  my $w;
+  
+  for my $i (0..$#$cron_entry) 
+  {
+      my @e = split /,/,$cron_entry->[$i];
+      my @res;
+      my $t;
+      while (defined($t = shift @e)) {
+          # Subst "*/5" -> "0-59/5"
+          $t =~ s|^\*(/.+)$|$RANGES[$i][0]."-".$RANGES[$i][1].$1|e; 
+          
+          if ($t =~ m|^([^-]+)-([^-/]+)(/(.*))?$|) 
+          {
+              my ($low,$high,$step) = ($1,$2,$4);
+              $step = 1 unless $step;
+              if ($low !~ /^(\d+)/) 
+              {
+                  $low = $ALPHACONV[$i]{lc $low};
+              }
+              if ($high !~ /^(\d+)/) 
+              {
+                  $high = $ALPHACONV[$i]{lc $high};
+              }
+              if (! defined($low) || !defined($high) ||  $low > $high || $step !~ /^\d+$/) 
+              {
+                  die "Invalid cronentry '",$cron_entry->[$i],"'";
+              }
+              my $j;
+              for ($j = $low; $j <= $high; $j += $step) 
+              {
+                  push @e,$j;
+              }
+          } 
+          else 
+          {
+              $t = $ALPHACONV[$i]{lc $t} if $t !~ /^(\d+|\*)$/;
+              $t = $LOWMAP[$i]{$t} if exists($LOWMAP[$i]{$t});
+              
+              die "Invalid cronentry '",$cron_entry->[$i],"'" 
+                if (!defined($t) || ($t ne '*' && ($t < $RANGES[$i][0] || $t > $RANGES[$i][1])));
+              push @res,$t;
+          }
+      }
+      push @expanded, ($#res == 0 && $res[0] eq '*') ? [@res] : [ sort { $a <=> $b} @res];
+  }
+  
+  # Calculating time:
+  # =================
+  my $now = $time || time;
+
+  if ($expanded[2]->[0] ne '*' && $expanded[4]->[0] ne '*') 
+  {
+      # Special check for which time is lower (Month-day or Week-day spec):
+      my @bak = @{$expanded[4]};
+      $expanded[4] = [ '*' ];
+      my $t1 = $self->_calc_time($now,\@expanded);
+      $expanded[4] = \@bak;
+      $expanded[2] = [ '*' ];
+      my $t2 = $self->_calc_time($now,\@expanded);
+      dbg "MDay : ",scalar(localtime($t1))," -- WDay : ",scalar(localtime($t2));
+      return $t1 < $t2 ? $t1 : $t2;
+  } 
+  else 
+  {
+      # No conflicts possible:
+      return $self->_calc_time($now,\@expanded);
+  }
+}
+
+# ==================================================
+# PRIVATE METHODS:
+# ==================================================
+
+# Build up executing queue and delete any
+# existing entries
+sub _build_initial_queue 
+{ 
+    my $self = shift;
+    $self->{queue} = [ ];
+    #  dbg "TT: ",$#{$self->{time_table}};
+    for my $id (0..$#{$self->{time_table}}) 
+    {
+        $self->_update_queue($id);
+    }
+}
+
+# deeply copy an entry in the time table
+sub _deep_copy_entry
+{
+    my ($self,$entry) = @_;
+
+    my $args = [ @{$entry->{args}} ];
+    my $copied_entry = { %$entry };
+    $copied_entry->{args} = $args;
+    return $copied_entry;
+}
+
+# Execute a subroutine whose time has come
+sub _execute 
+{ 
+  my $self = shift;
+  my $index = shift;
+  my $cfg = shift || $self->{cfg};
+  my $entry = $self->get_entry($index) 
+    || die "Internal: No entry with index $index found in ",Dumper([$self->list_entries()]);
+
+  my $pid;
+
+
+  my $log = $cfg->{log};
+
+  unless ($cfg->{nofork})
+  {
+      if ($pid = fork) 
+      {
+          # Parent
+          $log->(0,"Schedule::Cron - Forking child PID $pid") if $log;
+          # Register PID
+          $STARTEDCHILD{$pid} = 1;
+          return;
+      } 
+  }
+  
+  # Child
+  my $dispatch = $entry->{dispatcher};
+  die "No subroutine provided with $dispatch" 
+    unless ref($dispatch) eq "CODE";
+  my $args = $entry->{args};
+  
+  my @args = ();
+  if (defined($args) && defined($args->[0])) 
+  {
+      push @args,@$args;
+  }
+
+
+  my $args_label = @args ? "with (".join(",",$self->_format_args(@args)).")" : "";
+  $0 = $self->_get_process_prefix()." Dispatch $args_label"
+    unless $cfg->{nofork};
+  $log->(0,"Schedule::Cron - Starting job $index $args_label")
+    if $log;
+
+  my $dispatch_result;
+  if ($cfg->{catch})
+  {
+      # Evaluate dispatcher
+      eval
+      {
+          $dispatch_result = &$dispatch(@args);
+      };
+      if ($@)
+      {
+          $log->(2,"Schedule::Cron - Error within job $index: $@")
+            if $log;
+      }
+  }
+  else
+  {
+      # Let dispatcher die if needed.
+      $dispatch_result = &$dispatch(@args);
+  }
+  
+  if($cfg->{after_job}) {
+      my $job = $cfg->{after_job};
+      if (ref($job) eq "CODE") {
+          eval
+          {
+              &$job($dispatch_result,@args);
+          };
+          if ($@)
+          {
+              $log->(2,"Schedule::Cron - Error while calling after_job callback with retval = $dispatch_result: $@")
+                if $log;
+          }
+      } else {
+          $log->(2,"Schedule::Cron - Invalid after_job callback, it's not a code ref (but ",$job,")");
+      }
+  }
+
+  $log->(0,"Schedule::Cron - Finished job $index") if $log;
+  exit unless $cfg->{nofork};
+}
+
+# Udate the scheduler queue with a new entry
+sub _update_queue 
+{ 
+    my $self = shift;
+    
+    my $index = shift;
+    
+    my $entry = $self->get_entry($index);
+    
+    my $new_time = $self->get_next_execution_time($entry->{time});
+    dbg "Updating Queue: ",scalar(localtime($new_time));
+    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
+    #  dbg "Queue now: ",Dumper($self->{queue});
+}
+
+
+# The heart of the module.
+# calulate the next concrete date
+# for execution from a cronta entry
+sub _calc_time 
+{ 
+    my $self = shift;
+    my $now = shift;
+    my $expanded = shift;
+
+    my $offset = ($expanded->[5] ? 1 : 60);
+    my ($now_sec,$now_min,$now_hour,$now_mday,$now_mon,$now_wday,$now_year) = 
+      (localtime($now+$offset))[0,1,2,3,4,6,5];
+    $now_mon++; 
+    $now_year += 1900;
+
+    # Notes on variables set:
+    # $now_... : the current date, fixed at call time
+    # $dest_...: date used for backtracking. At the end, it contains
+    #            the desired lowest matching date
+    
+    my ($dest_mon,$dest_mday,$dest_wday,$dest_hour,$dest_min,$dest_sec,$dest_year) = 
+      ($now_mon,$now_mday,$now_wday,$now_hour,$now_min,$now_sec,$now_year);
+    
+    while ($dest_year <= $now_year + 1) 
+    { # Airbag...
+        dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday";
+        
+        
+        # Check month:
+        if ($expanded->[3]->[0] ne '*') 
+        {
+            unless (defined ($dest_mon = $self->_get_nearest($dest_mon,$expanded->[3]))) 
+            {
+                $dest_mon = $expanded->[3]->[0];
+                $dest_year++;
+            } 
+        } 
+  
+        # Check for day of month:
+        if ($expanded->[2]->[0] ne '*') 
+        {           
+            if ($dest_mon != $now_mon) 
+            {      
+                $dest_mday = $expanded->[2]->[0];
+            } 
+            else 
+            {
+                unless (defined ($dest_mday = $self->_get_nearest($dest_mday,$expanded->[2]))) 
+                {
+                    # Next day matched is within the next month. ==> redo it
+                    $dest_mday = $expanded->[2]->[0];
+                    $dest_mon++;
+                    if ($dest_mon > 12) 
+                    {
+                        $dest_mon = 1;
+                        $dest_year++;
+                    }
+                    dbg "Backtrack mday: $dest_mday/$dest_mon/$dest_year";
+                    next;
+                }
+            }
+        } 
+        else 
+        {
+            $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
+        }
+  
+        # Check for day of week:
+        if ($expanded->[4]->[0] ne '*') 
+        {
+            $dest_wday = $self->_get_nearest($dest_wday,$expanded->[4]);
+            $dest_wday = $expanded->[4]->[0] unless $dest_wday;
+    
+            my ($mon,$mday,$year);
+            #      dbg "M: $dest_mon MD: $dest_mday WD: $dest_wday Y:$dest_year";
+            $dest_mday = 1 if $dest_mon != $now_mon;
+            my $t = parsedate(sprintf("%4.4d/%2.2d/%2.2d",$dest_year,$dest_mon,$dest_mday));
+            ($mon,$mday,$year) =  
+              (localtime(parsedate("$WDAYS[$dest_wday]",PREFER_FUTURE=>1,NOW=>$t-1)))[4,3,5]; 
+            $mon++;
+            $year += 1900;
+            
+            dbg "$mday/$mon/$year";
+            if ($mon != $dest_mon || $year != $dest_year) {
+                dbg "backtracking";
+                $dest_mon = $mon;
+                $dest_year = $year;
+                $dest_mday = 1;
+                $dest_wday = (localtime(parsedate(sprintf("%4.4d/%2.2d/%2.2d",
+                                                          $dest_year,$dest_mon,$dest_mday))))[6];
+                next;
+            }
+            
+            $dest_mday = $mday;
+        } 
+        else 
+        {
+            unless ($dest_mday) 
+            {
+                $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
+            }
+        }
+  
+        # Check for hour
+        if ($expanded->[1]->[0] ne '*') 
+        {
+            if ($dest_mday != $now_mday) 
+            {
+                $dest_hour = $expanded->[1]->[0];
+            } 
+            else 
+            {
+#       dbg "Checking for next hour $dest_hour";
+                unless (defined ($dest_hour = $self->_get_nearest($dest_hour,$expanded->[1]))) 
+                {
+                    # Hour to match is at the next day ==> redo it
+                    $dest_hour = $expanded->[1]->[0];
+                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
+                    ($dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                      (localtime(parsedate("+ 1 day",NOW=>$t)))[3,4,5,6];
+                    $dest_mon++; 
+                    $dest_year += 1900;
+                    next; 
+                }
+            }
+        } 
+        else 
+        {
+            $dest_hour = ($dest_mday == $now_mday ? $dest_hour : 0);
+        }
+    
+        # Check for minute
+        if ($expanded->[0]->[0] ne '*') 
+        {
+            if ($dest_hour != $now_hour) 
+            {
+                $dest_min = $expanded->[0]->[0];
+            } 
+            else 
+            {
+                unless (defined ($dest_min = $self->_get_nearest($dest_min,$expanded->[0]))) 
+                {
+                    # Minute to match is at the next hour ==> redo it
+                    $dest_min = $expanded->[0]->[0];
+                    my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                              $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday));
+                    ($dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                      (localtime(parsedate(" + 1 hour",NOW=>$t)))  [2,3,4,5,6];
+                    $dest_mon++;
+                    $dest_year += 1900;
+                    next;
+                }
+            }
+        } 
+        else 
+        {
+            $dest_min = ($dest_hour == $now_hour ? $dest_min : 0);
+        }
+
+        # Check for seconds
+        if ($expanded->[5])
+        {
+            if ($expanded->[5]->[0] ne '*')
+            {
+                if ($dest_min != $now_min) 
+                {
+                    $dest_sec = $expanded->[5]->[0];
+                } 
+                else 
+                {
+                    unless (defined ($dest_sec = $self->_get_nearest($dest_sec,$expanded->[5]))) 
+                    {
+                        # Second to match is at the next minute ==> redo it
+                        $dest_sec = $expanded->[5]->[0];
+                        my $t = parsedate(sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                                                  $dest_hour,$dest_min,$dest_sec,
+                                                  $dest_year,$dest_mon,$dest_mday));
+                        ($dest_min,$dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) = 
+                          (localtime(parsedate(" + 1 minute",NOW=>$t)))  [1,2,3,4,5,6];
+                        $dest_mon++;
+                        $dest_year += 1900;
+                        next;
+                    }
+                }
+            } 
+            else 
+            {
+                $dest_sec = ($dest_min == $now_min ? $dest_sec : 0);
+            }
+        }
+        else
+        {
+            $dest_sec = 0;
+        }
+
+        
+        # We did it !!
+        my $date = sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
+                           $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday);
+        dbg "Next execution time: $date ",
+          $WDAYS[$dest_wday];
+        return parsedate($date);
+    }
+}
+
+# get next entry in list or 
+# undef if is the highest entry found
+sub _get_nearest 
+{ 
+  my $self = shift;
+  my $x = shift;
+  my $to_check = shift;
+  foreach my $i (0 .. $#$to_check) 
+  {
+      if ($$to_check[$i] >= $x) 
+      {
+          return $$to_check[$i] ;
+      }
+  }
+  return undef;
+}
+
+
+# prepare a list of object for pretty printing e.g. in the process list
+sub _format_args {
+    my $self = shift;
+    my @args = @_;
+    my $dumper = new Data::Dumper(\@args);
+    $dumper->Terse(1);
+    $dumper->Maxdepth(2);
+    $dumper->Indent(0);
+    return $dumper->Dump();
+}
+
+# get the prefix to use when setting $0
+sub _get_process_prefix { 
+    my $self = shift;
+    my $prefix = $self->{cfg}->{processprefix} || "Schedule::Cron";
+    return $prefix;
+}
+
+# our very own debugging routine
+# ('guess everybody has its own style ;-)
+sub dbg  
+{
+  if ($DEBUG) 
+  {
+      my $args = join('',@_) || "";
+      my $caller = (caller(1))[0];
+      my $line = (caller(0))[2];
+      $caller ||= $0;
+      if (length $caller > 22) 
+      {
+          $caller = substr($caller,0,10)."..".substr($caller,-10,10);
+      }
+      print STDERR sprintf ("%02d:%02d:%02d [%22.22s %4.4s]  %s\n",
+                            (localtime)[2,1,0],$caller,$line,$args);
+  }
+}
+
+# Helper method for reporting bugs concerning calculation
+# of execution bug:
+*bug = \&report_exectime_bug;   # Shortcut
+sub report_exectime_bug 
+{
+  my $self = shift;
+  my $endless = shift;
+  my $time = time;
+  my $inp;
+  my $now = $self->_time_as_string($time);
+  my $email;
+
+  do 
+  {
+      while (1) 
+      {
+          $inp = $self->_get_input("Reference time\n(default: $now)  : ");
+          if ($inp) 
+          {
+              parsedate($inp) || (print "Couldn't parse \"$inp\"\n",next);
+              $now = $inp;
+          }
+          last;
+      }
+      my $now_time = parsedate($now);
+    
+      my ($next_time,$next);
+      my @entries;
+      while (1) 
+      {
+          $inp = $self->_get_input("Crontab time (5 columns)            : ");
+          @entries = split (/\s+/,$inp);
+          if (@entries != 5) 
+          {
+              print "Invalid crontab entry \"$inp\"\n";
+              next;
+          }
+          eval 
+          { 
+              local $SIG{ALRM} = sub {  die "TIMEOUT" };
+              alarm(60);
+              $next_time = Schedule::Cron->get_next_execution_time(\@entries,$now_time);
+              alarm(0);
+          };
+          if ($@) 
+          {
+              alarm(0);
+              if ($@ eq "TIMEOUT") 
+              {
+                  $next_time = -1;
+              } else 
+              {
+                  print "Invalid crontab entry \"$inp\" ($@)\n";
+                  next;
+              }
+          }
+        
+          if ($next_time > 0) 
+          {
+              $next = $self->_time_as_string($next_time);
+          } else 
+          {
+              $next = "Run into infinite loop !!";
+          }
+          last;
+      }
+    
+      my ($expected,$expected_time);
+      while (1) 
+      {
+          $inp = $self->_get_input("Expected time                       : ");
+          unless ($expected_time = parsedate($inp)) 
+          {
+              print "Couldn't parse \"$inp\"\n";
+              next;
+          } 
+          $expected = $self->_time_as_string($expected_time);
+          last;
+      }
+    
+      # Print out bug report:
+      if ($expected eq $next) 
+      {
+          print "\nHmm, seems that everything's ok, or ?\n\n";
+          print "Calculated time: ",$next,"\n";
+          print "Expected time  : ",$expected,"\n";
+      } else 
+      {
+          print <<EOT;
+Congratulation, you hit a bug. 
+
+EOT
+          $email = $self->_get_input("Your E-Mail Address (if available)  : ") 
+            unless defined($email);
+          $email = "" unless defined($email);
+      
+          print "\n","=" x 80,"\n";
+          print <<EOT;
+Please report the following lines
+to roland\@cpan.org
+
+EOT
+          print "# ","-" x 78,"\n";
+          print "Reftime: ",$now,"\n";
+          print "# Reported by : ",$email,"\n" if $email;
+          printf "%8s %8s %8s %8s %8s         %s\n",@entries,$expected;
+          print "# Calculated  : \n";
+          printf "# %8s %8s %8s %8s %8s         %s\n",@entries,$next;
+          unless ($endless) 
+          {
+              require Config;
+              my $vers = `uname -r 2>/dev/null` || $Config::Config{'osvers'} ;
+              chomp $vers;
+              my $osname = `uname -s 2>/dev/null` || $Config::Config{'osname'};
+              chomp $osname;
+              print "# OS: $osname ($vers)\n";
+              print "# Perl-Version: $]\n";
+              print "# Time::ParseDate-Version: ",$Time::ParseDate::VERSION,"\n";
+          }
+          print "# ","-" x 78,"\n";
+      }
+    
+      print "\n","=" x 80,"\n";
+  } while ($endless);
+}
+
+my ($input_initialized,$term);
+sub _get_input 
+{ 
+  my $self = shift;
+  my $prompt = shift;
+  use vars qw($term);
+
+  unless (defined($input_initialized)) 
+  {
+      eval { require Term::ReadLine; };
+    
+      $input_initialized = $@ ? 0 : 1;
+      if ($input_initialized) 
+      {
+          $term = new Term::ReadLine;
+          $term->ornaments(0);
+      }
+  }
+  
+  unless ($input_initialized) 
+  {
+      print $prompt;
+      my $inp = <STDIN>;
+      chomp $inp;
+      return $inp;
+  } 
+  else 
+  {
+      chomp $prompt;
+      my @prompt = split /\n/s,$prompt;
+      if ($#prompt > 0)
+      {
+          print join "\n",@prompt[0..$#prompt-1],"\n";
+      }
+      my $inp = $term->readline($prompt[$#prompt]);
+      return $inp;
+  }
+}
+
+sub _time_as_string 
+{ 
+  my $self = shift;
+  my $time = shift; 
+
+  my ($min,$hour,$mday,$month,$year,$wday) = (localtime($time))[1..6];
+  $month++;
+  $year += 1900;
+  $wday = $WDAYS[$wday];
+  return sprintf("%2.2d:%2.2d %2.2d/%2.2d/%4.4d %s",
+                 $hour,$min,$mday,$month,$year,$wday);
+}
+
+=back
+
+=head1 TODO
+
+=over 
+
+=item *
+
+Provide a C<reload()> method for reexaming the crontab file 
+
+=back
+
+
+=head1 LICENSE
+
+Copyright 1999-2009 Roland Huss.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
+=head1 AUTHOR
+
+                                                    ...roland
+
+=cut
+
+1;
+
+
+
+
-- 
cgit v1.2.3


From 714f6ec69547d020085fd1daac360bd97c128bf5 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 22 Mar 2009 17:50:37 +0000
Subject: adapted version number

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index c66101c..983cde9 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -81,7 +81,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.98_01";
+$VERSION = "0.97_01";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 18daea9136c64e27aa065082b6242e7551050700 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Mon, 23 Mar 2009 22:09:11 +0000
Subject: fixed calc bugs

---
 CHANGES              |  5 ++--
 ChangeLog            |  7 +++++
 META.yml             |  8 ++----
 lib/Schedule/Cron.pm | 56 +++++++++++++++++++++++++++-------------
 t/execution_time.t   | 72 +++++++++++++++++++++++++++++++++++++++++++++++-----
 5 files changed, 116 insertions(+), 32 deletions(-)

diff --git a/CHANGES b/CHANGES
index 07159b4..5df87ec 100644
--- a/CHANGES
+++ b/CHANGES
@@ -3,9 +3,10 @@
 - New option 'after_job' for new() which allows for a callback run after a 
   job has been sucessfully run (RT #29040)
 - Argument logging is done using data dumper (RT #39499)
-- Private methods are now marked with _
+- Private methods are now marked with '_'
 - Added tests for increasin kwallitee
-- Switched to Build.PL (Makefile.PL is still supported)
+- Switched over to Build.PL (Makefile.PL is still supported)
+- Fixed some time calculation times
 
 0.97
 
diff --git a/ChangeLog b/ChangeLog
index 7ed55be..81b11f7 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2009-03-23  Roland Huss  <roland@consol.de>
+
+	* lib/Schedule/Cron.pm (_calc_time): fixed some issues when
+	calculating times for '*' entries
+
+	* t/execution_time.t: Added test for checking proper DST behaviour
+
 2009-03-21  Roland Huss  <roland@consol.de>
 
 	* Cron.pm (_time_as_string): marked all private subs to start with '_'
diff --git a/META.yml b/META.yml
index 6852f9c..3d4054c 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.98_01
+version: 0.97_01
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -20,12 +20,8 @@ recommends:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.98_01
+    version: 0.97_01
 generated_by: Module::Build version 0.31012
-keywords:
-    - Cron
-    - Scheduler
-    - Job
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.2.html
   version: 1.2
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 983cde9..ce79632 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -680,12 +680,12 @@ are recognized:
 
 =over
 
-=item   detach    
+=item detach    
 
 If set to a true value the scheduler process is detached from the current
 process (UNIX only).
 
-=item  pid_file  
+=item pid_file  
 
 If running in daemon mode, name the optional file, in which the process id of
 the scheduler process should be written. By default, no PID File will be
@@ -1135,7 +1135,7 @@ sub _update_queue
 
 # The heart of the module.
 # calulate the next concrete date
-# for execution from a cronta entry
+# for execution from a crontab entry
 sub _calc_time 
 { 
     my $self = shift;
@@ -1152,15 +1152,17 @@ sub _calc_time
     # $now_... : the current date, fixed at call time
     # $dest_...: date used for backtracking. At the end, it contains
     #            the desired lowest matching date
-    
+
     my ($dest_mon,$dest_mday,$dest_wday,$dest_hour,$dest_min,$dest_sec,$dest_year) = 
       ($now_mon,$now_mday,$now_wday,$now_hour,$now_min,$now_sec,$now_year);
-    
+
+    dbg Dumper($expanded);
+
+    # Airbag...
     while ($dest_year <= $now_year + 1) 
-    { # Airbag...
+    { 
         dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday";
         
-        
         # Check month:
         if ($expanded->[3]->[0] ne '*') 
         {
@@ -1215,7 +1217,7 @@ sub _calc_time
             $mon++;
             $year += 1900;
             
-            dbg "$mday/$mon/$year";
+            dbg "Calculated $mday/$mon/$year for weekday ",$WDAYS[$dest_wday];
             if ($mon != $dest_mon || $year != $dest_year) {
                 dbg "backtracking";
                 $dest_mon = $mon;
@@ -1235,17 +1237,18 @@ sub _calc_time
                 $dest_mday = ($dest_mon == $now_mon ? $dest_mday : 1);
             }
         }
+
   
         # Check for hour
         if ($expanded->[1]->[0] ne '*') 
         {
-            if ($dest_mday != $now_mday) 
+            if ($dest_mday != $now_mday || $dest_mon != $now_mon || $dest_year != $now_year) 
             {
                 $dest_hour = $expanded->[1]->[0];
             } 
             else 
             {
-#       dbg "Checking for next hour $dest_hour";
+                #dbg "Checking for next hour $dest_hour";
                 unless (defined ($dest_hour = $self->_get_nearest($dest_hour,$expanded->[1]))) 
                 {
                     # Hour to match is at the next day ==> redo it
@@ -1268,7 +1271,7 @@ sub _calc_time
         # Check for minute
         if ($expanded->[0]->[0] ne '*') 
         {
-            if ($dest_hour != $now_hour) 
+            if ($dest_hour != $now_hour || $dest_mday != $now_mday || $dest_mon != $dest_mon || $dest_year != $now_year) 
             {
                 $dest_min = $expanded->[0]->[0];
             } 
@@ -1290,7 +1293,11 @@ sub _calc_time
         } 
         else 
         {
-            $dest_min = ($dest_hour == $now_hour ? $dest_min : 0);
+            if ($dest_hour != $now_hour ||
+                $dest_mday != $now_mday ||
+                $dest_year != $now_year) {
+                $dest_min = 0;
+            } 
         }
 
         # Check for seconds
@@ -1328,15 +1335,30 @@ sub _calc_time
         {
             $dest_sec = 0;
         }
-
         
         # We did it !!
         my $date = sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
                            $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday);
-        dbg "Next execution time: $date ",
-          $WDAYS[$dest_wday];
-        return parsedate($date);
-    }
+        dbg "Next execution time: $date ",$WDAYS[$dest_wday];
+        my $result = parsedate($date, VALIDATE => 1);
+        # Check for a valid date
+        if ($result)
+        {
+            # Valid date... return it!
+            return $result;
+        }
+        else
+        {
+            # Invalid date i.e. (02/30/2008). Retry it with another, possibly
+            # valid date            
+            my $t = parsedate($date); print scalar(localtime($t)),"\n";
+            ($dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) =
+              (localtime(parsedate(" + 1 second",NOW=>$t)))  [2,3,4,5,6];
+            $dest_mon++;
+            $dest_year += 1900;
+            next;
+        }
+   }
 }
 
 # get next entry in list or 
diff --git a/t/execution_time.t b/t/execution_time.t
index 0fdc40d..9e11a7f 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -1,18 +1,37 @@
 #!perl -w
 
+
 use Test::More;
 use Schedule::Cron;
 use Time::ParseDate;
-
+use Data::Dumper;
+
+eval "use DateTime::TimeZone::Local";
+my $local_tz;
+if (!$@) {
+    my $t = DateTime::TimeZone::Local->TimeZone();
+    if ($t) {
+        $local_tz = $t->name();
+    }
+}
 my $time;
-
-while (defined($_=<DATA>) && $_ !~ /end/i) {
+my $skip = 0;
+while (defined($_=<DATA>) && $_ !~ /^end/i) {
   chomp;
+  next if $skip;
   if (/^Reftime:\s*(.*)$/) {
-    $time = $1;
-    $time =~ s/\#.*$//;
-    $time = parsedate($time,UK=>1);
-    next;
+      $time = $1;
+      $time =~ s/\#.*$//;
+      $time = parsedate($time,UK=>1);
+      next;
+  } elsif (/^TZBEGIN:\s*(.*)$/) {
+      if (!$local_tz || $1 ne $local_tz) {
+          $skip = 1; 
+      }
+      next;
+  } elsif (/^TZEND:/) {
+      $skip = 0;
+      next;
   }
   s/^\s*(.*)\s*/$1/;
   next if /^\#/ || /^$/;
@@ -133,6 +152,45 @@ Reftime: Mon Dec 27 20:14:14 1999
 	    5,10,25,30,35,40,45,50,55 * * * *             20:25 27/12/1999 Monday
         */5                       *   *  * 	*         20:15 27/12/1999 Monday
 
+# Runs only if running if in Germany (since the DST is TZ specific)
+TZBEGIN: Europe/Berlin
+# DST Checks (for MEZ)
+# ====================
+# Normal behaviour (non-DST related)
+Reftime: Sun Mar 29 03:10:00 2009
+       10 * * * *                                     Sun Mar 29 04:10:00 2009
+       10 2 * * *                                     Mon Mar 30 02:10:00 2009 
+       10 2 * * 0                                     Sun Apr 05 02:10:00 2009
+       10 2 29 * *                                    Wed Apr 29 02:10:00 2009
+# Cron triggers within the DST switch. It should fire right after the hours has 
+# changed
+Reftime: Sun Mar 29 01:10:00 2009
+       10 * * * *                                     Sun Mar 29 03:10:00 2009
+Reftime: Sat Mar 28 02:10:00 2009
+       10 2 * * *                                     Sun Mar 29 03:10:00 2009
+Reftime: Sun Mar 22 02:10:00 2009
+       10 2 * * 0                                     Sun Mar 29 03:10:00 2009
+Reftime: Sun Feb 29 02:10:00 2009
+       10 2 29 * *                                    Sun Mar 29 03:10:00 2009
+TZEND: Europe/Berlin
+
+# ----------------------------------------------------------------------------
+# Leave out invalid dates
+Reftime: Fri Feb 27 12:00:00 2009
+       0 12 30 * *                                     Sun Mar 30 12:00:00 2009                     
+
+# Check '*' at minute level
+Reftime: Fri Jan 27 12:01:00 2009
+       * 12 30 * *                                     Sun Jan 30 12:00:00 2009 
+       * 12 27 * *                                     Sun Jan 27 12:02:00 2009 
+       * 12 *  * *                                     Sun Jan 27 12:02:00 2009 
+       * 13 *  * *                                     Sun Jan 27 13:00:00 2009 
+
+# -----------------------------------------------------------------------------
+# Reported by : tenbrink
+Reftime: 23:00 2007/09/01
+       0 23 * * 1                                      23:00 03/09/2007 Monday
+
 end
 
 
-- 
cgit v1.2.3


From f4f39a5bd37d54390a77c852484e9c9cadbaf51d Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Thu, 26 Mar 2009 18:06:16 +0000
Subject: added some more checks and make test more robust

---
 CHANGES              |  1 +
 ChangeLog            |  5 +++++
 META.yml             |  4 ++--
 README               |  3 +--
 lib/Schedule/Cron.pm | 48 ++++++++++++++++++++++++++++++++++++++++++------
 t/execution_time.t   | 10 ++++++----
 6 files changed, 57 insertions(+), 14 deletions(-)

diff --git a/CHANGES b/CHANGES
index 5df87ec..7b0cbc8 100644
--- a/CHANGES
+++ b/CHANGES
@@ -7,6 +7,7 @@
 - Added tests for increasin kwallitee
 - Switched over to Build.PL (Makefile.PL is still supported)
 - Fixed some time calculation times
+- Allow comments at the end of a crontab line
 
 0.97
 
diff --git a/ChangeLog b/ChangeLog
index 81b11f7..71df563 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,8 @@
+2009-03-24  Roland Huss  <roland@consol.de>
+
+	* lib/Schedule/Cron.pm (load_crontab): Allow comment at the end of 
+	a crontab line
+
 2009-03-23  Roland Huss  <roland@consol.de>
 
 	* lib/Schedule/Cron.pm (_calc_time): fixed some issues when
diff --git a/META.yml b/META.yml
index 3d4054c..7dd9a23 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.97_01
+version: 0.97_02
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -20,7 +20,7 @@ recommends:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.97_01
+    version: 0.97_02
 generated_by: Module::Build version 0.31012
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.2.html
diff --git a/README b/README
index 34734ca..9899f1c 100644
--- a/README
+++ b/README
@@ -145,6 +145,5 @@ This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
 
 Enjoy it...
-							    ...roland
-                                                       roland@cpan.org
+							    ...roland (roland@cpan.org)
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index ce79632..7c9b643 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -81,7 +81,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.97_01";
+$VERSION = "0.97_02";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -328,6 +328,10 @@ sub load_crontab
   while (<F>) 
   {
       $line++;
+      # Strip off trailing comments and ignore empty 
+      # or pure comments lines:
+      s/#.*$//;
+      next if /^$/;
       next if /^$/;
       next if /^\s*#/;
       chomp;
@@ -749,14 +753,16 @@ sub run
                       if $log;
                     $self->_update_queue($index);
                     next;
-                }
+                }  
             }
             else
             {
                 $sleep = $time - $now;
             }
             $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time));
-            die "No time found\n" unless $time;
+            if (!$time) {
+                die "Internal: No time found, self: ",$self->{queue},"\n" unless $time;
+            }
 
             dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")";
             while ($sleep > 0) 
@@ -977,9 +983,12 @@ sub get_next_execution_time
               push @res,$t;
           }
       }
-      push @expanded, ($#res == 0 && $res[0] eq '*') ? [@res] : [ sort { $a <=> $b} @res];
+      push @expanded, ($#res == 0 && $res[0] eq '*') ? [ "*" ] : [ sort {$a <=> $b} @res];
   }
   
+  # Check for strange bug
+  $self->_verify_expanded_cron_entry($cron_entry,\@expanded);
+
   # Calculating time:
   # =================
   my $now = $time || time;
@@ -1156,7 +1165,7 @@ sub _calc_time
     my ($dest_mon,$dest_mday,$dest_wday,$dest_hour,$dest_min,$dest_sec,$dest_year) = 
       ($now_mon,$now_mday,$now_wday,$now_hour,$now_min,$now_sec,$now_year);
 
-    dbg Dumper($expanded);
+    # dbg Dumper($expanded);
 
     # Airbag...
     while ($dest_year <= $now_year + 1) 
@@ -1358,7 +1367,14 @@ sub _calc_time
             $dest_year += 1900;
             next;
         }
-   }
+    }
+
+    # Die with an error because we couldnt find a next execution entry
+    my $dumper = new Data::Dumper($expanded);
+    $dumper->Terse(1);
+    $dumper->Indent(0);
+
+    die "No suitable next execution time found for ",$dumper->Dump(),", now == ",scalar(localtime($now)),"\n";
 }
 
 # get next entry in list or 
@@ -1594,6 +1610,26 @@ sub _time_as_string
                  $hour,$min,$mday,$month,$year,$wday);
 }
 
+
+# As reported by RT Ticket #24712 sometimes, 
+# the expanded version of the cron entry is flaky.
+# However, this occurs only very rarely and randomly. 
+# So, we need to provide good diagnostics when this 
+# happens
+sub _verify_expanded_cron_entry {
+    my $self = shift;
+    my $original = shift;
+    my $entry = shift;
+    die "Internal: Not an array ref. Orig: ",Dumper($original), ", expanded: ",Dumper($entry)," (self = ",Dumper($self),")"
+      unless ref($entry) eq "ARRAY";
+    
+    for my $i (0 .. $#{$entry}) {
+        die "Internal: Part $i of entry is not an array ref. Original: ",
+          Dumper($original),", expanded: ",Dumper($entry)," (self=",Dumper($self),")",
+            unless ref($entry->[$i]) eq "ARRAY";
+    }    
+}
+
 =back
 
 =head1 TODO
diff --git a/t/execution_time.t b/t/execution_time.t
index 9e11a7f..06f0dab 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -9,10 +9,12 @@ use Data::Dumper;
 eval "use DateTime::TimeZone::Local";
 my $local_tz;
 if (!$@) {
-    my $t = DateTime::TimeZone::Local->TimeZone();
-    if ($t) {
-        $local_tz = $t->name();
-    }
+    eval {
+        my $t = DateTime::TimeZone::Local->TimeZone();
+        if ($t) {
+            $local_tz = $t->name();
+        }
+    }; # Needs to eval because a time zone might not be set
 }
 my $time;
 my $skip = 0;
-- 
cgit v1.2.3


From b5f978e163f486dcdca0051265bcbe0208c33c17 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Thu, 26 Mar 2009 19:54:52 +0000
Subject:

---
 README                 | 26 ++++++++++++++++++--------
 t/callbackreschedule.t |  2 +-
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/README b/README
index 9899f1c..bf263f0 100644
--- a/README
+++ b/README
@@ -77,35 +77,45 @@ In order  to install and use  this package you will  need Perl version
 (contained in the Time-modules-xx.xxxxx) available on CPAN.
 
 You need a fork()-aware Perl for dispatching the cron jobs. This might
-change in the future. On systems without a fork() system call you can
+change in the future. On systems  without a fork() system call you can
 use the 'nofork' option to run your jobs within the current process.
 
 OS-DEPENDENCIES
 ---------------
 
 Schedule::Cron was tested on a Redhat Linux-Box, but it should work on
-any UNIX  Box (still  to be  tested). In depends  on some  UNIX system
-calls for starting jobs and detaching itself to the background:
+any UNIX Box.  In depends on some original UNIX system calls for
+starting jobs and detaching itself to the background:
 
   * It uses fork() for starting jobs
   * For  detaching it  uses either  setsid (POSIX)  or the  ioctl call
     TIOCNOTTY
 
-So at  the moment, it probably  won't run on any  'foreign' ports like
-the Win32- or MacOs-Port.
+The roadmap  include plans  for porting the  fork mechanism over  to a
+thread based scheme, which should make dynamic update much easier.
 
-These restrictions might be relaxed in the future.
+If the  system calls mentioned  above are not available  (which should
+hapen nowadays only  under rare circumstances), you can  still use the
+'nofork' option to run all jobs within a single process/thread. Please
+refer to the documentation for further reading.
 
 INSTALLATION
 ------------
 
-As usual:
+Installation can be don either in the old fashioned way
 
    perl Makefile.PL
    make
    make test
    make install
 
+or alternatively with Module::Build
+
+   perl Build.PL
+   ./Build 
+   ./Build test
+   ./Build install
+
 See the  documentation for  Schedule::Cron for a  detailed description
 and further usage examples.
 
@@ -145,5 +155,5 @@ This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
 
 Enjoy it...
-							    ...roland (roland@cpan.org)
+                                            ...roland (roland@cpan.org)
 
diff --git a/t/callbackreschedule.t b/t/callbackreschedule.t
index 0c788c3..90a71bf 100644
--- a/t/callbackreschedule.t
+++ b/t/callbackreschedule.t
@@ -38,4 +38,4 @@ eval
 {
     $cron->run();
 };
-ok($@ eq "ok\n","rescheduled jobs work properly");
+ok($@ eq "ok\n","rescheduled jobs work properly ($@)");
-- 
cgit v1.2.3


From e776cd1e5b8c2223013bee05da928a7bc58e6ac5 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sat, 28 Mar 2009 18:27:50 +0000
Subject: added examples

---
 examples/simple.pl | 33 +++++++++++++++++++++++++++++++++
 1 file changed, 33 insertions(+)
 create mode 100644 examples/simple.pl

diff --git a/examples/simple.pl b/examples/simple.pl
new file mode 100644
index 0000000..8038db9
--- /dev/null
+++ b/examples/simple.pl
@@ -0,0 +1,33 @@
+#!/usr/bin/perl
+
+# Very simple examples which print the current 
+# time every 10 Minutes.
+#
+# The purpose is to show a common usage pattern 
+# using a single dispatcher subroutine provided
+# at construction time
+
+use lib "../lib";
+use Schedule::Cron;
+
+# Create new object with default dispatcher
+my $cron = new Schedule::Cron(\&dispatcher);
+
+# The cron entry which fires every 10 minutes
+my $entry = "0-59/10 * * * *";
+
+# Dispatcher subroutine called from cron
+sub dispatcher { 
+    open(T,">>timestamps.txt");
+    print T "Current: ",scalar(localtime),"\n";
+    print T "Next:    ",scalar(localtime($cron->get_next_execution_time($entry))),"\n";
+    close T;
+}
+
+
+# Call &dispatcher() every ten minutes
+$cron->add_entry($entry);
+
+# Run scheduler and block. 'nofork' forces the subroutine to 
+# be called in the main process
+$cron->run(nofork=>1);
-- 
cgit v1.2.3


From 4e93330e06df4e5ec2558c8b7f27e29fd5a4a9d5 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 29 Mar 2009 08:39:45 +0000
Subject: made timings a bit more relaxed

---
 t/startup.t | 40 ++++++++++++++++++++++------------------
 1 file changed, 22 insertions(+), 18 deletions(-)

diff --git a/t/startup.t b/t/startup.t
index be11919..d7a9805 100644
--- a/t/startup.t
+++ b/t/startup.t
@@ -6,29 +6,33 @@
 use Schedule::Cron;
 use Test::More tests => 1;
 
+our %SKIP;
+
 $| = 1;
 #print STDERR " (may take a minute) ";
 
 SKIP: {
     eval { alarm 0 };
-    skip "alarm() not available", 1 if $@;
-
-    $SIG{QUIT} = sub { 
-        alarm(0);
-        pass;
-        exit;
-    };
-    
-    $SIG{ALRM} = sub { 
-        fail;
-        exit;
-    };
-    
-    $cron = new Schedule::Cron(sub { kill QUIT, shift; alarm 0; });
-    $cron->add_entry("* * * * * *",$$);
-    
-    alarm(5);
-    $cron->run;
+    if ($@) {
+        skip "alarm() not available", 1 if $@;
+    } else {
+        $SIG{QUIT} = sub { 
+            alarm(0);
+            pass;
+            exit;
+        };
+        
+        $SIG{ALRM} = sub { 
+            fail;
+            exit;
+        };
+        
+        $cron = new Schedule::Cron(sub { kill QUIT, shift; alarm 1; });
+        $cron->add_entry("* * * * * */2",$$);
+        
+        alarm(6);
+        $cron->run;
+    }
 }
 
 
-- 
cgit v1.2.3


From b5127b509d02f6f261d91dc78bac66bb8bfb342b Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 29 Mar 2009 08:44:08 +0000
Subject: made timings a bit more relaxed

---
 t/callbackreschedule.t | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/t/callbackreschedule.t b/t/callbackreschedule.t
index 90a71bf..abff19a 100644
--- a/t/callbackreschedule.t
+++ b/t/callbackreschedule.t
@@ -18,8 +18,8 @@ sub dispatch_1 {
    print "# Job 1.1, job1count: $job1count, job2count: $job2count\n";
    if ($job1count++ == 0) {
       $cron->clean_timetable;
-      $cron->add_entry("* * * * * 0-59/2", \&dispatch_2);
-      $cron->add_entry("* * * * * 1-59/2");
+      $cron->add_entry("* * * * * 0-59/4", \&dispatch_2);
+      $cron->add_entry("* * * * * 2-59/4");
    } else {
       die "ok\n" if $job2count;
       die "job2 never ran";
@@ -33,9 +33,11 @@ sub dispatch_2 {
    }
 }
 
-$cron->add_entry("* * * * * 1-59/2");
+$cron->add_entry("* * * * * 2-59/4");
 eval
 {
     $cron->run();
 };
-ok($@ eq "ok\n","rescheduled jobs work properly ($@)");
+my $error = $@;
+chomp $error;
+ok($error eq "ok","rescheduled jobs work properly ($error)");
-- 
cgit v1.2.3


From b7f3a2151e85c0b10d6a86b765d8cd0e6fe50207 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 29 Mar 2009 09:05:12 +0000
Subject: tuned test a bit

---
 t/sighandler.t | 38 ++++++++++++++++++++------------------
 1 file changed, 20 insertions(+), 18 deletions(-)

diff --git a/t/sighandler.t b/t/sighandler.t
index 1aa4d23..370b7c3 100644
--- a/t/sighandler.t
+++ b/t/sighandler.t
@@ -10,22 +10,24 @@ $| = 1;
 
 SKIP: {
     eval { alarm 0 };
-    skip "alarm() not available", 1 if $@;
-
-    # Check, whether an already installed signalhandler is called
-    $SIG{CHLD} = sub { 
-        pass;
-        exit;
-    };
-    
-    $SIG{ALRM} = sub { 
-        fail;
-        exit;
-    };
-    
-    
-    my $cron = new Schedule::Cron(sub { sleep(1) });
-    $cron->add_entry("* * * * * */2");
-    alarm(5);
-    $cron->run;
+    if ($@) {
+        skip "alarm() not available", 1 if $@;
+    } else {
+        # Check, whether an already installed signalhandler is called
+        $SIG{CHLD} = sub { 
+            pass;
+            exit 0;
+        };
+        
+        $SIG{ALRM} = sub { 
+            fail;
+            exit 0;
+        };
+        
+        
+        my $cron = new Schedule::Cron(sub { sleep(1); });
+        $cron->add_entry("* * * * * *");
+        alarm(5);
+        $cron->run;
+    }
 }
-- 
cgit v1.2.3


From c5fd46390804b91298820f43b247930d3e2b0b53 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 29 Mar 2009 09:06:03 +0000
Subject: fixed docs

---
 lib/Schedule/Cron.pm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 7c9b643..467e709 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -383,7 +383,7 @@ The time and date fields are (taken mostly from L<crontab(5)>, "Vixie" cron):
    hour           0-23
    day of month   1-31 
    month          1-12 (or as names)
-   day of week    0-7 (0 or 7 is Sunday, or as names )
+   day of week    0-7 (0 or 7 is Sunday, or as names)
    seconds        0-59 (optional)
 
  A field may be an asterisk (*), which always stands for
@@ -1080,7 +1080,7 @@ sub _execute
 
 
   my $args_label = @args ? "with (".join(",",$self->_format_args(@args)).")" : "";
-  $0 = $self->_get_process_prefix()." Dispatch $args_label"
+  $0 = $self->_get_process_prefix()." Dispatched with $args_label"
     unless $cfg->{nofork};
   $log->(0,"Schedule::Cron - Starting job $index $args_label")
     if $log;
-- 
cgit v1.2.3


From 6376cc6896e8314e87bbb5b6792a78e73c815daa Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Sun, 29 Mar 2009 09:07:33 +0000
Subject:

---
 MANIFEST | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MANIFEST b/MANIFEST
index 2f8ba91..7de012e 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -6,6 +6,7 @@ Build.PL
 MANIFEST			This list of files
 META.yml
 README
+examples/simple.pl
 t/after_job.t
 t/callbackreschedule.t
 t/entry.t
-- 
cgit v1.2.3


From 81ad5e110616a34516f151d22abb14020c134d47 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 3 Apr 2009 07:42:51 +0000
Subject: added increased logging and reformatted

---
 t/nofork.t     | 16 ++++++++++------
 t/sighandler.t | 37 ++++++++++++++++++-------------------
 t/startup.t    | 37 +++++++++++++++++--------------------
 3 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/t/nofork.t b/t/nofork.t
index a558bdd..1c8ba37 100644
--- a/t/nofork.t
+++ b/t/nofork.t
@@ -19,7 +19,7 @@ my $dispatch_2 =
       print "# Job 1.2\n";
       if ($toggle)
       {
-          pass("Second Job finished");
+          pass("Simple nofork - Second Job finished");
           die "ok\n";
       }
       $count++;
@@ -34,7 +34,9 @@ eval
 {
     $cron->run();
 };
-ok($@ eq "ok\n","Cron has been run: $@");
+my $error = $@;
+chomp $error;
+ok($error eq "ok","Simple nofork - Cron has been run: $error");
 
 # No fork with 'skip' option
 $count = 0;
@@ -43,7 +45,7 @@ $dispatch_1 =
       print "# Job 2.1  ",scalar(localtime),"\n";
       if ($count == 1)
       {
-          pass("Skip test passed");
+          pass("Nofork with skip - Skip test passed");
           die "ok\n";
       }
       $count++;
@@ -63,7 +65,9 @@ eval
 {
     $cron->run(skip => 1);
 };
-ok($@ eq "ok\n","Cron has been run: $@");
+$error = $@;
+chomp $error;
+ok($error eq "ok","Nofork with skip - Cron has been run: $error");
 
 # No-Fork with 'catch' option.
 $count = 0;
@@ -79,7 +83,7 @@ SKIP: {
       };
     
     $SIG{ALRM} = sub { 
-        ok($count > 0,"Job has run");
+        ok($count > 0,"Nofork with skip - Job has run");
         exit;
     };
     
@@ -90,7 +94,7 @@ SKIP: {
         alarm(3);
         $cron->run(catch => 1);
     };
-    ok(!$@,"Job has died: $@");
+    ok(!$@,"Nofork with skip - Job has died: $@");
  }
 
 
diff --git a/t/sighandler.t b/t/sighandler.t
index 370b7c3..25583b0 100644
--- a/t/sighandler.t
+++ b/t/sighandler.t
@@ -10,24 +10,23 @@ $| = 1;
 
 SKIP: {
     eval { alarm 0 };
-    if ($@) {
-        skip "alarm() not available", 1 if $@;
-    } else {
-        # Check, whether an already installed signalhandler is called
-        $SIG{CHLD} = sub { 
-            pass;
+    skip "alarm() not available", 1 if $@;
+    
+    # Check, whether an already installed signalhandler is called
+    $SIG{CHLD} = sub { 
+        pass;
+        exit 0;
+    };
+    
+    $SIG{ALRM} = sub { 
+        fail;
             exit 0;
-        };
-        
-        $SIG{ALRM} = sub { 
-            fail;
-            exit 0;
-        };
-        
-        
-        my $cron = new Schedule::Cron(sub { sleep(1); });
-        $cron->add_entry("* * * * * *");
-        alarm(5);
-        $cron->run;
-    }
+    };
+    
+    
+    my $cron = new Schedule::Cron(sub { sleep(1); });
+    $cron->add_entry("* * * * * *");
+    alarm(5);
+    $cron->run;
 }
+
diff --git a/t/startup.t b/t/startup.t
index d7a9805..f239912 100644
--- a/t/startup.t
+++ b/t/startup.t
@@ -13,26 +13,23 @@ $| = 1;
 
 SKIP: {
     eval { alarm 0 };
-    if ($@) {
-        skip "alarm() not available", 1 if $@;
-    } else {
-        $SIG{QUIT} = sub { 
-            alarm(0);
-            pass;
-            exit;
-        };
-        
-        $SIG{ALRM} = sub { 
-            fail;
-            exit;
-        };
-        
-        $cron = new Schedule::Cron(sub { kill QUIT, shift; alarm 1; });
-        $cron->add_entry("* * * * * */2",$$);
-        
-        alarm(6);
-        $cron->run;
-    }
+    skip "alarm() not available", 1 if $@;
+    $SIG{QUIT} = sub { 
+        alarm(0);
+        pass;
+        exit;
+    };
+    
+    $SIG{ALRM} = sub { 
+        fail;
+        exit;
+    };
+    
+    $cron = new Schedule::Cron(sub { kill QUIT, shift; alarm 1; });
+    $cron->add_entry("* * * * * */2",$$);
+    
+    alarm(6);
+    $cron->run;
 }
 
 
-- 
cgit v1.2.3


From e2a153902af9452741712d62ceeb71e344b4b793 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 3 Apr 2009 07:44:15 +0000
Subject: advanced to 0.98

---
 META.yml             | 4 ++--
 lib/Schedule/Cron.pm | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/META.yml b/META.yml
index 7dd9a23..f47e0e9 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.97_02
+version: 0.98
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -20,7 +20,7 @@ recommends:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.97_02
+    version: 0.98
 generated_by: Module::Build version 0.31012
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.2.html
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 467e709..bd1d81b 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -81,7 +81,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.97_02";
+$VERSION = "0.98";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 0b589c814d088496df9ef35747a3d4f4d1182512 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 3 Apr 2009 07:44:45 +0000
Subject:

---
 examples/simple.pl | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/examples/simple.pl b/examples/simple.pl
index 8038db9..72dac8e 100644
--- a/examples/simple.pl
+++ b/examples/simple.pl
@@ -14,7 +14,7 @@ use Schedule::Cron;
 my $cron = new Schedule::Cron(\&dispatcher);
 
 # The cron entry which fires every 10 minutes
-my $entry = "0-59/10 * * * *";
+my $entry = "0-59/5 * * * *";
 
 # Dispatcher subroutine called from cron
 sub dispatcher { 
@@ -22,6 +22,7 @@ sub dispatcher {
     print T "Current: ",scalar(localtime),"\n";
     print T "Next:    ",scalar(localtime($cron->get_next_execution_time($entry))),"\n";
     close T;
+    sleep(30);
 }
 
 
-- 
cgit v1.2.3


From 16de37a4e93f938ca929b9c9ad62fdb3a5675ffd Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 3 Apr 2009 07:44:56 +0000
Subject:

---
 CHANGES   | 28 +++++++++++++---------------
 ChangeLog |  4 ++++
 2 files changed, 17 insertions(+), 15 deletions(-)

diff --git a/CHANGES b/CHANGES
index 7b0cbc8..a0b4110 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,40 +1,38 @@
 0.98
 
-- New option 'after_job' for new() which allows for a callback run after a 
-  job has been sucessfully run (RT #29040)
+- New option 'after_job' for new() which allows for a callback run
+  after a job has been sucessfully run (RT #29040)
 - Argument logging is done using data dumper (RT #39499)
 - Private methods are now marked with '_'
-- Added tests for increasin kwallitee
+- Added tests for increased kwallitee
 - Switched over to Build.PL (Makefile.PL is still supported)
-- Fixed some time calculation times
+- Fixed some time calculation times (e.g. for the first DST switch in
+  the year)  
 - Allow comments at the end of a crontab line
 
 0.97
 
-- Use POSIX only where available, otherwise fallback to an emulation of waipid.
-- Fixed bug when previous SIGCHLD handler was not a coderef, but a String value like 
-  "DEFAULT" or "IGNORE"
+- Use POSIX only where available, otherwise fallback to an emulation
+  of waipid. 
+- Fixed bug when previous SIGCHLD handler was not a coderef, but a
+  String value like "DEFAULT" or "IGNORE"
 - Added tests
-- Made test more robust so they work now also on system without alarm() functionality 
-  (Win32)
+- Made test more robust so they work now also on system without
+  alarm() functionality (Win32)
 
 0.96 
 
-- Applied patch for #4917 in order to be smarter to existing SIGCHLD handler and to 
-  reap only own childs.
+- Applied patch for #4917 in order to be smarter to existing SIGCHLD
+  handler and to reap only own childs.
 
 0.95 
 
 - If a scheduled method in 'nofork' manipulates the execution queue with 
   add_entry or delete_entry, it will be picked up during the next run. 
-
 - Clarified different behaviour of global variables within the fork/norfork 
   mode in the documentation
-
 - Fixed warning about non-numeric arguments when sorting. 
-
 - Fixed bug which called to an undefined methods in a die-message
-
 - Pretty print a hashref in $0 if provided as argument and the 
   prefix for the name to be shown in the process list can be configured
   with the option "processprefix"
diff --git a/ChangeLog b/ChangeLog
index 71df563..30759bd 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2009-04-03  Roland Huss  <roland@consol.de>
+
+	* Released Version 0.98
+
 2009-03-24  Roland Huss  <roland@consol.de>
 
 	* lib/Schedule/Cron.pm (load_crontab): Allow comment at the end of 
-- 
cgit v1.2.3


From 1cd8d902376f69448dbbee6e49a669b0be733a10 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 17 Jul 2009 09:44:34 +0000
Subject: added some additional tests

---
 t/execution_time.t | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/t/execution_time.t b/t/execution_time.t
index 06f0dab..307828c 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -174,6 +174,15 @@ Reftime: Sun Mar 22 02:10:00 2009
        10 2 * * 0                                     Sun Mar 29 03:10:00 2009
 Reftime: Sun Feb 29 02:10:00 2009
        10 2 29 * *                                    Sun Mar 29 03:10:00 2009
+
+# Checks for reverse DST switch. It should skip the extra hour.
+Reftime: Sun Oct 25 02:10:00 2009
+       10  * * * *                                    Sun Oct 25 03:10:00 2009
+Reftime: Sun Oct 25 02:10:00 2009
+       5  * * * *                                     Sun Oct 25 03:05:00 2009
+Reftime: Sun Oct 25 02:55:00 2009
+       25  * * * *                                    Sun Oct 25 03:25:00 2009
+
 TZEND: Europe/Berlin
 
 # ----------------------------------------------------------------------------
@@ -193,6 +202,8 @@ Reftime: Fri Jan 27 12:01:00 2009
 Reftime: 23:00 2007/09/01
        0 23 * * 1                                      23:00 03/09/2007 Monday
 
+
+
 end
 
 
-- 
cgit v1.2.3


From 390cea851cd57c876cd941c830332cf11c1881b4 Mon Sep 17 00:00:00 2001
From: Roland Huss <roland@cpan.org>
Date: Fri, 17 Jul 2009 09:45:04 +0000
Subject: fixed typo

---
 Build.PL | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Build.PL b/Build.PL
index f69884b..a2f7e5c 100644
--- a/Build.PL
+++ b/Build.PL
@@ -24,7 +24,7 @@ my $build = Module::Build->new
                   "sys::ioctl.ph" => 0,
                   "Module::Build" => 0
                  },
-   keywords => [  "Cron", "Scheduler", "Jon" ],
+   keywords => [  "Cron", "Scheduler", "Job" ],
    provides => {
                 "Schedule::Cron" => {
                                file =>  "lib/Schedule/Cron.pm"
-- 
cgit v1.2.3


From 67b0db97683cef4db633ec8773016b3f8ef299d7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Thu, 3 Sep 2009 21:44:18 +0200
Subject: Added fix for bug when DST switches back and a job scheduling goes
 amok when fired within this hour.

---
 Build.PL             |  3 ++-
 lib/Schedule/Cron.pm | 22 ++++++++++++++++++----
 t/dst_back.t         | 16 ++++++++++++++++
 3 files changed, 36 insertions(+), 5 deletions(-)
 create mode 100644 t/dst_back.t

diff --git a/Build.PL b/Build.PL
index a2f7e5c..aafc5c3 100644
--- a/Build.PL
+++ b/Build.PL
@@ -17,7 +17,8 @@ my $build = Module::Build->new
    
    build_requires => {
                       "Test::More" => "0",
-                      "Test" => "0"
+                      "Test" => "0",
+                      "Time::Mock" => "0",
                      },                       
    recommends => {
                   "ioctl.ph" => 0,
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index bd1d81b..9977f24 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -81,7 +81,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.98";
+$VERSION = "0.99_1";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -742,7 +742,7 @@ sub run
     {
         while (42) 
         {
-            my ($index,$time) = @{shift @{$self->{queue}}};
+            my ($index,$time,$dst_back) = @{shift @{$self->{queue}}};
             my $now = time;
             my $sleep = 0;
             if ($time < $now)
@@ -753,7 +753,18 @@ sub run
                       if $log;
                     $self->_update_queue($index);
                     next;
-                }  
+                }
+                if ($dst_back) {
+                    # We are adding hours as long as we have a negative sleep
+                    # interval: 
+                    $sleep = $time - $now;
+                    do { 
+                        $sleep += 3600;
+                    } while ($sleep < 0);
+                    dbg "Adjusted sleep to $sleep because of DST back flip (time - now = ",$time - $now,")";
+                }
+                # At least a safety airbag
+                $sleep = 1 unless $sleep;
             }
             else
             {
@@ -1136,8 +1147,11 @@ sub _update_queue
     my $entry = $self->get_entry($index);
     
     my $new_time = $self->get_next_execution_time($entry->{time});
+    # Check, whether next execution time is *smaller* than the current time.
+    # This can happen during DST backflip:
+    my $dst_back = $new_time < time ? 1 : 0;
     dbg "Updating Queue: ",scalar(localtime($new_time));
-    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
+    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time,$dst_back] ];
     #  dbg "Queue now: ",Dumper($self->{queue});
 }
 
diff --git a/t/dst_back.t b/t/dst_back.t
new file mode 100644
index 0000000..da825dd
--- /dev/null
+++ b/t/dst_back.t
@@ -0,0 +1,16 @@
+#!perl -w
+
+use strict;
+use warnings;
+use Test::More;
+
+eval { require Time::Mock };
+if( $@ ) {
+    plan skip_all => 'Time::Mock not installed';
+}
+else {
+    plan tests => 1;
+}
+
+# TODO: Test for checking, whether Scheduling in the DST back flip works
+ok(1);
-- 
cgit v1.2.3


From 0aabe874c2287b68a6f705e1cdeb5529cc4fdcdc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sat, 5 Sep 2009 16:50:30 +0200
Subject: Fine tuned fixed and added doc + test.

---
 Build.PL             |  1 -
 CHANGES              |  5 ++++
 ChangeLog            |  8 ++++++
 MANIFEST             |  5 ++--
 META.yml             | 18 +++++++------
 lib/Schedule/Cron.pm | 73 ++++++++++++++++++++++++++++++----------------------
 t/dst_back.t         | 23 +++++++++++------
 t/execution_time.t   |  7 ++++-
 8 files changed, 89 insertions(+), 51 deletions(-)

diff --git a/Build.PL b/Build.PL
index aafc5c3..388c3e3 100644
--- a/Build.PL
+++ b/Build.PL
@@ -18,7 +18,6 @@ my $build = Module::Build->new
    build_requires => {
                       "Test::More" => "0",
                       "Test" => "0",
-                      "Time::Mock" => "0",
                      },                       
    recommends => {
                   "ioctl.ph" => 0,
diff --git a/CHANGES b/CHANGES
index a0b4110..263948c 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,8 @@
+0.99
+- Fixed issue when switching back DST which can result into amok 
+  running jobs during this period. The behaviour for jobs triggered
+  within this rewinded hour is still not defined properly (yet). 
+
 0.98
 
 - New option 'after_job' for new() which allows for a callback run
diff --git a/ChangeLog b/ChangeLog
index 30759bd..c906c84 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,11 @@
+2009-09-05  Roland Huss  <roland@consol.de>
+
+	* lib/Schedule/Cron.pm: Fixed issue for certain timeszone (like
+	PST8PDT) where a backward DST switch make Cron.pm running amok by
+	firing each job triggered in the extra hour without a delay
+	between. Thanks A LOT to Eric Wilhelm for spotting and analysing
+	this issue.
+	 
 2009-04-03  Roland Huss  <roland@consol.de>
 
 	* Released Version 0.98
diff --git a/MANIFEST b/MANIFEST
index 7de012e..46736a9 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,14 +1,15 @@
+Build.PL
 ChangeLog
 CHANGES
+examples/simple.pl
 lib/Schedule/Cron.pm
 Makefile.PL
-Build.PL
 MANIFEST			This list of files
 META.yml
 README
-examples/simple.pl
 t/after_job.t
 t/callbackreschedule.t
+t/dst_back.t
 t/entry.t
 t/execution_time.t
 t/kwalitee.t
diff --git a/META.yml b/META.yml
index f47e0e9..c59cda3 100644
--- a/META.yml
+++ b/META.yml
@@ -1,27 +1,29 @@
 ---
 name: Schedule-Cron
-version: 0.98
+version: 0.99_2
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
 license: perl
 resources:
   license: http://dev.perl.org/licenses/
-requires:
-  Data::Dumper: 0
-  Time::ParseDate: 99.00
 build_requires:
   Test: 0
   Test::More: 0
+requires:
+  Data::Dumper: 0
+  Time::ParseDate: 99.00
 recommends:
   Module::Build: 0
   ioctl.ph: 0
   sys::ioctl.ph: 0
+configure_requires:
+  Module::Build: 0.34
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.98
-generated_by: Module::Build version 0.31012
+    version: 0.99_2
+generated_by: Module::Build version 0.34
 meta-spec:
-  url: http://module-build.sourceforge.net/META-spec-v1.2.html
-  version: 1.2
+  url: http://module-build.sourceforge.net/META-spec-v1.4.html
+  version: 1.4
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 9977f24..b61aba7 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1,7 +1,5 @@
 #!/usr/bin/perl -w
 
-# $Id: Cron.pm,v 1.16 2006/11/27 13:42:52 roland Exp $
-
 =head1 NAME
 
 Cron - cron-like scheduler for Perl subroutines
@@ -81,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.99_1";
+$VERSION = "0.99_2";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -742,7 +740,7 @@ sub run
     {
         while (42) 
         {
-            my ($index,$time,$dst_back) = @{shift @{$self->{queue}}};
+            my ($index,$time) = @{shift @{$self->{queue}}};
             my $now = time;
             my $sleep = 0;
             if ($time < $now)
@@ -754,17 +752,8 @@ sub run
                     $self->_update_queue($index);
                     next;
                 }
-                if ($dst_back) {
-                    # We are adding hours as long as we have a negative sleep
-                    # interval: 
-                    $sleep = $time - $now;
-                    do { 
-                        $sleep += 3600;
-                    } while ($sleep < 0);
-                    dbg "Adjusted sleep to $sleep because of DST back flip (time - now = ",$time - $now,")";
-                }
                 # At least a safety airbag
-                $sleep = 1 unless $sleep;
+                $sleep = 1;
             }
             else
             {
@@ -1141,17 +1130,23 @@ sub _execute
 sub _update_queue 
 { 
     my $self = shift;
-    
     my $index = shift;
-    
     my $entry = $self->get_entry($index);
     
     my $new_time = $self->get_next_execution_time($entry->{time});
     # Check, whether next execution time is *smaller* than the current time.
     # This can happen during DST backflip:
-    my $dst_back = $new_time < time ? 1 : 0;
+    my $now = time;
+    if ($new_time < $now) {
+        dbg "Adjusting time calculation because of DST back flip (new_time - now = ",$new_time - $now,")";
+        # We are adding hours as long as our target time is in the future
+        while ($new_time < $now) {
+            $new_time += 3600;
+        }
+    }
+
     dbg "Updating Queue: ",scalar(localtime($new_time));
-    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time,$dst_back] ];
+    $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
     #  dbg "Queue now: ",Dumper($self->{queue});
 }
 
@@ -1290,7 +1285,6 @@ sub _calc_time
         {
             $dest_hour = ($dest_mday == $now_mday ? $dest_hour : 0);
         }
-    
         # Check for minute
         if ($expanded->[0]->[0] ne '*') 
         {
@@ -1322,7 +1316,6 @@ sub _calc_time
                 $dest_min = 0;
             } 
         }
-
         # Check for seconds
         if ($expanded->[5])
         {
@@ -1374,7 +1367,7 @@ sub _calc_time
         {
             # Invalid date i.e. (02/30/2008). Retry it with another, possibly
             # valid date            
-            my $t = parsedate($date); print scalar(localtime($t)),"\n";
+            my $t = parsedate($date); # print scalar(localtime($t)),"\n";
             ($dest_hour,$dest_mday,$dest_mon,$dest_year,$dest_wday) =
               (localtime(parsedate(" + 1 second",NOW=>$t)))  [2,3,4,5,6];
             $dest_mon++;
@@ -1646,16 +1639,34 @@ sub _verify_expanded_cron_entry {
 
 =back
 
-=head1 TODO
-
-=over 
-
-=item *
-
-Provide a C<reload()> method for reexaming the crontab file 
-
-=back
-
+=head1 DST ISSUES
+
+Daylight saving occurs typically twice a year: In the first switch, one hour is
+skipped. Any job which would trigger in this skipped hour will be fired in the
+next hour. So, when the DST switch goes from 2:00 to 3:00 a job would is
+scheduled for 2:43, then it will be executed at 3:43.
+
+For the reverse, backwards switch later in the year, the behaviour is
+undefined. Two possible behaviours can occur: For jobs triggered in short
+intervals, where the next execution time would fire in the extra hour as well,
+the job could be executed again or skipped in this extra hour. For the time
+being running C<Schedule::Cron> in C<MET> would skip the extra job, in
+C<PST8PDT> it would execute a second time. The reason is the way how
+L<Time::ParseDate> calculates epoch times for dates given like C<02:50:00
+2009/10/25>. Should it return the seconds since 1970 for this time happening
+'first', or for this time in the extra hour ?. As it turns out,
+L<Time::ParseDate> returns the seconds for the first occurence for C<PST8PDT>
+and for the second occurence for C<MET>. Unfortunately, there is no way to
+specify I<which> entry L<Time::ParseDate> should pick (until now). Of course,
+after all, this is obviously not L<Time::ParseDate>'s fault, since a simple
+date specification within the DST backswitch period B<is> ambigious.
+
+Since changing the algorithm which worked now for over ten years would be too
+risky and I don't see any simple solution for this right now, it is likely that
+this I<undefined> behaviour will exist for some time. Maybe some hero is coming
+along and will fix this, but this is probably not me ;-)
+
+Sorry for that.
 
 =head1 LICENSE
 
diff --git a/t/dst_back.t b/t/dst_back.t
index da825dd..290ea01 100644
--- a/t/dst_back.t
+++ b/t/dst_back.t
@@ -3,14 +3,21 @@
 use strict;
 use warnings;
 use Test::More;
+use Schedule::Cron;
 
-eval { require Time::Mock };
-if( $@ ) {
-    plan skip_all => 'Time::Mock not installed';
-}
-else {
-    plan tests => 1;
+plan tests => 3;
+
+my @refs = ( 
+            [ "MET", 1256432100, 1256436000],
+            [ "Europe/Berlin", 1256432100, 1256436000],
+            [ "PST8PDT", 1257065700, 1257062400]
+           );
+
+my $cron = new Schedule::Cron(sub { });
+
+for my $r (@refs) {
+    $ENV{TZ} = $r->[0];
+    my $next = $cron->get_next_execution_time("0-59/5 * * * *",$r->[1]);
+    is($next,$r->[2],"Expected time for " . $r->[0] . "( Ref: " . scalar(localtime($r->[1])) . ", Calc: " . scalar(localtime($next)));
 }
 
-# TODO: Test for checking, whether Scheduling in the DST back flip works
-ok(1);
diff --git a/t/execution_time.t b/t/execution_time.t
index 307828c..71874cf 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -175,7 +175,12 @@ Reftime: Sun Mar 22 02:10:00 2009
 Reftime: Sun Feb 29 02:10:00 2009
        10 2 29 * *                                    Sun Mar 29 03:10:00 2009
 
-# Checks for reverse DST switch. It should skip the extra hour.
+# Checks for reverse DST switch. It should skip the extra hour.  This works for
+# MET only, though. Actually for other TZs (like PST8PDT), where parsedate()
+# delivers the 'first' UTC time instead of the 'second' (as it is for MET).
+# This is not Time::ParseDate's fault but ours because of the way, how we
+# calculate the next execution time. It's unlikely that this will get fixed
+# very soon.
 Reftime: Sun Oct 25 02:10:00 2009
        10  * * * *                                    Sun Oct 25 03:10:00 2009
 Reftime: Sun Oct 25 02:10:00 2009
-- 
cgit v1.2.3


From f99c094a3af70c2585c3c4db35ff4de4004b48f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sat, 5 Sep 2009 16:56:27 +0200
Subject: Fixed docs.

---
 lib/Schedule/Cron.pm | 36 ++++++++++++++++++------------------
 1 file changed, 18 insertions(+), 18 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b61aba7..1a6dd92 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1642,29 +1642,29 @@ sub _verify_expanded_cron_entry {
 =head1 DST ISSUES
 
 Daylight saving occurs typically twice a year: In the first switch, one hour is
-skipped. Any job which would trigger in this skipped hour will be fired in the
+skipped. Any job which which triggers in this skipped hour will be fired in the
 next hour. So, when the DST switch goes from 2:00 to 3:00 a job would is
 scheduled for 2:43, then it will be executed at 3:43.
 
-For the reverse, backwards switch later in the year, the behaviour is
+For the reverse backwards switch later in the year, the behaviour is
 undefined. Two possible behaviours can occur: For jobs triggered in short
 intervals, where the next execution time would fire in the extra hour as well,
-the job could be executed again or skipped in this extra hour. For the time
-being running C<Schedule::Cron> in C<MET> would skip the extra job, in
-C<PST8PDT> it would execute a second time. The reason is the way how
-L<Time::ParseDate> calculates epoch times for dates given like C<02:50:00
-2009/10/25>. Should it return the seconds since 1970 for this time happening
-'first', or for this time in the extra hour ?. As it turns out,
-L<Time::ParseDate> returns the seconds for the first occurence for C<PST8PDT>
-and for the second occurence for C<MET>. Unfortunately, there is no way to
-specify I<which> entry L<Time::ParseDate> should pick (until now). Of course,
-after all, this is obviously not L<Time::ParseDate>'s fault, since a simple
-date specification within the DST backswitch period B<is> ambigious.
-
-Since changing the algorithm which worked now for over ten years would be too
-risky and I don't see any simple solution for this right now, it is likely that
-this I<undefined> behaviour will exist for some time. Maybe some hero is coming
-along and will fix this, but this is probably not me ;-)
+the job could be executed again or skipped in this extra hour. Currently,
+running C<Schedule::Cron> in C<MET> would skip the extra job, in C<PST8PDT> it
+would execute a second time. The reason is the way how L<Time::ParseDate>
+calculates epoch times for dates given like C<02:50:00 2009/10/25>. Should it
+return the seconds since 1970 for this time happening 'first', or for this time
+in the extra hour ? As it turns out, L<Time::ParseDate> returns the seconds
+for the first occurence for C<PST8PDT> and for the second occurence for
+C<MET>. Unfortunately, there is no way to specify I<which> entry
+L<Time::ParseDate> should pick (until now). Of course, after all, this is
+obviously not L<Time::ParseDate>'s fault, since a simple date specification
+within the DST backswitch period B<is> ambigious.
+
+Since changing the internal algorithm which worked now for over ten years would
+be too risky and I don't see any simple solution for this right now, it is
+likely that this I<undefined> behaviour will exist for some time. Maybe some
+hero is coming along and will fix this, but this is probably not me ;-)
 
 Sorry for that.
 
-- 
cgit v1.2.3


From 564a80e42390c875cd5e6a3fe8234941d3e78267 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Fri, 11 Sep 2009 20:31:30 +0200
Subject: final touches

---
 META.yml             |  4 ++--
 lib/Schedule/Cron.pm | 15 +++++++++------
 t/dst_back.t         | 26 ++++++++++++++++++++++++--
 t/sighandler.t       |  2 +-
 4 files changed, 36 insertions(+), 11 deletions(-)

diff --git a/META.yml b/META.yml
index c59cda3..02390a0 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.99_2
+version: 0.99_3
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -22,7 +22,7 @@ configure_requires:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.99_2
+    version: 0.99_3
 generated_by: Module::Build version 0.34
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 1a6dd92..715f371 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.99_2";
+$VERSION = "0.99";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -1654,12 +1654,15 @@ running C<Schedule::Cron> in C<MET> would skip the extra job, in C<PST8PDT> it
 would execute a second time. The reason is the way how L<Time::ParseDate>
 calculates epoch times for dates given like C<02:50:00 2009/10/25>. Should it
 return the seconds since 1970 for this time happening 'first', or for this time
-in the extra hour ? As it turns out, L<Time::ParseDate> returns the seconds
-for the first occurence for C<PST8PDT> and for the second occurence for
-C<MET>. Unfortunately, there is no way to specify I<which> entry
+in the extra hour ? As it turns out, L<Time::ParseDate> returns the epoch time
+of the first occurence for C<PST8PDT> and for C<MET> it returns the second
+occurence. Unfortunately, there is no way to specify I<which> entry
 L<Time::ParseDate> should pick (until now). Of course, after all, this is
 obviously not L<Time::ParseDate>'s fault, since a simple date specification
-within the DST backswitch period B<is> ambigious.
+within the DST backswitch period B<is> ambigious. However, it would be nice if
+the parsing behaviour of L<Time::ParseDate> would be consistent across time
+zones (a ticket has be raised for fixing this). Then L<Schedule::Cron>'s
+behaviour within a DST backward switch would be consistent as well.
 
 Since changing the internal algorithm which worked now for over ten years would
 be too risky and I don't see any simple solution for this right now, it is
@@ -1677,7 +1680,7 @@ modify it under the same terms as Perl itself.
 
 =head1 AUTHOR
 
-                                                    ...roland
+... roland
 
 =cut
 
diff --git a/t/dst_back.t b/t/dst_back.t
index 290ea01..cb7428f 100644
--- a/t/dst_back.t
+++ b/t/dst_back.t
@@ -7,17 +7,39 @@ use Schedule::Cron;
 
 plan tests => 3;
 
+
+my %available = ();
+
 my @refs = ( 
             [ "MET", 1256432100, 1256436000],
             [ "Europe/Berlin", 1256432100, 1256436000],
             [ "PST8PDT", 1257065700, 1257062400]
            );
 
+# First check for timezones available:
+no warnings;
+$ENV{TZ} = undef;
+my $tt = time;
+my $local = scalar(localtime($tt));
+for my $r (@refs) {
+    my $tz = $r->[0];
+    $ENV{TZ} = $tz;
+    my $calc = scalar(localtime($tt));
+    #print "C: $calc L: $local\n";
+    $available{$tz} = 1 if $calc ne $local;
+}
+
+
 my $cron = new Schedule::Cron(sub { });
 
 for my $r (@refs) {
-    $ENV{TZ} = $r->[0];
+    my $tz = $r->[0];
+    if (!$available{$tz}) {
+        ok(1,"Timezone $tz not available");
+        next;
+    }
+    $ENV{TZ} = $tz;
     my $next = $cron->get_next_execution_time("0-59/5 * * * *",$r->[1]);
-    is($next,$r->[2],"Expected time for " . $r->[0] . "( Ref: " . scalar(localtime($r->[1])) . ", Calc: " . scalar(localtime($next)));
+    is($next,$r->[2],"Expected time for $tz ( Ref: " . scalar(localtime($r->[1])) . ", Calc: " . scalar(localtime($next)));
 }
 
diff --git a/t/sighandler.t b/t/sighandler.t
index 25583b0..b2389bf 100644
--- a/t/sighandler.t
+++ b/t/sighandler.t
@@ -20,7 +20,7 @@ SKIP: {
     
     $SIG{ALRM} = sub { 
         fail;
-            exit 0;
+        exit 0;
     };
     
     
-- 
cgit v1.2.3


From a3e231c7d46e41eaadd14c211e4d7b803a8c5957 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sat, 12 Sep 2009 09:15:42 +0200
Subject: final touches

---
 META.yml             | 4 ++--
 lib/Schedule/Cron.pm | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/META.yml b/META.yml
index 02390a0..b64ab3d 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.99_3
+version: 0.99
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -22,7 +22,7 @@ configure_requires:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.99_3
+    version: 0.99
 generated_by: Module::Build version 0.34
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 715f371..55a489d 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -35,7 +35,7 @@ Cron - cron-like scheduler for Perl subroutines
 =head1 DESCRIPTION
 
 This module provides a simple but complete cron like scheduler.  I.e this
-modules can be used for periodically executing Perl subroutines.  The dates and
+module can be used for periodically executing Perl subroutines.  The dates and
 parameters for the subroutines to be called are specified with a format known
 as crontab entry (see L<"METHODS">, C<add_entry()> and L<crontab(5)>)
 
-- 
cgit v1.2.3


From 9d6b72b0c28141c047852e3b023d4b35417f9882 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sat, 12 Sep 2009 09:16:20 +0200
Subject: final touches

---
 ChangeLog | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/ChangeLog b/ChangeLog
index c906c84..6f6f572 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,7 @@
+2009-09-12  Roland Huss  <roland@consol.de>
+
+	* Released Version 0.99
+
 2009-09-05  Roland Huss  <roland@consol.de>
 
 	* lib/Schedule/Cron.pm: Fixed issue for certain timeszone (like
-- 
cgit v1.2.3


From 4ce82a615c672be4d1cbf3c81cf383c9906bd102 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sat, 12 Sep 2009 09:16:47 +0200
Subject: final touches

---
 CHANGES | 1 +
 1 file changed, 1 insertion(+)

diff --git a/CHANGES b/CHANGES
index 263948c..c5b66f5 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,4 +1,5 @@
 0.99
+
 - Fixed issue when switching back DST which can result into amok 
   running jobs during this period. The behaviour for jobs triggered
   within this rewinded hour is still not defined properly (yet). 
-- 
cgit v1.2.3


From 61f4660dda82ec77fc8a2a414b66d7620616c20b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Tue, 13 Oct 2009 17:20:13 +0200
Subject: Fixed Bug #50325

---
 lib/Schedule/Cron.pm | 12 ++++++------
 t/execution_time.t   |  5 +++++
 2 files changed, 11 insertions(+), 6 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 55a489d..7fe016b 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -41,15 +41,15 @@ as crontab entry (see L<"METHODS">, C<add_entry()> and L<crontab(5)>)
 
 The philosophy behind C<Schedule::Cron> is to call subroutines periodically
 from within one single Perl program instead of letting C<cron> trigger several
-(possibly different) perl scripts. Everything under one roof.  Furthermore
+(possibly different) Perl scripts. Everything under one roof.  Furthermore,
 C<Schedule::Cron> provides mechanism to create crontab entries dynamically,
 which isn't that easy with C<cron>.
 
 C<Schedule::Cron> knows about all extensions (well, at least all extensions I'm
 aware of, i.e those of the so called "Vixie" cron) for crontab entries like
-ranges including 'steps', specification of month and days of the week by name
-or coexistence of lists and ranges in the same field.  And even a bit more
-(like lists and ranges with symbolic names).
+ranges including 'steps', specification of month and days of the week by name,
+or coexistence of lists and ranges in the same field.  It even supports a bit
+more (like lists and ranges with symbolic names).
 
 =head1 METHODS
 
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "0.99";
+$VERSION = "1.00_1";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -110,7 +110,7 @@ my @RANGES = (
               [ 0,31 ],
               [ 0,12 ],
               [ 0,7  ],
-              [ 0,60 ]
+              [ 0,59 ]
              );
 
 my @LOWMAP = ( 
diff --git a/t/execution_time.t b/t/execution_time.t
index 71874cf..4ff8a79 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -207,6 +207,11 @@ Reftime: Fri Jan 27 12:01:00 2009
 Reftime: 23:00 2007/09/01
        0 23 * * 1                                      23:00 03/09/2007 Monday
 
+# -----------------------------------------------------------------------------
+# Reported by : tenbrink
+Reftime: 23:00:55 2007/09/01
+       * * * * * */10                                  23:01:00 01/09/2007 Saturday
+
 
 
 end
-- 
cgit v1.2.3


From c323cb545ab8c63d0f0257883a2ee3dd144635cb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Thu, 15 Oct 2009 16:06:46 +0200
Subject: disabled test for win32

---
 t/sighandler.t | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/t/sighandler.t b/t/sighandler.t
index b2389bf..121e658 100644
--- a/t/sighandler.t
+++ b/t/sighandler.t
@@ -4,8 +4,13 @@
 # $Id: sighandler.t,v 1.2 2006/11/27 13:42:52 roland Exp $
 
 use Schedule::Cron;
-use Test::More tests => 1;
+use Test::More;
 
+if ($^O =~ /Win32/i) {
+    plan skip_all => "Test doesn't work on Win32";
+} else {
+    plan tests => 1;
+}
 $| = 1;
 
 SKIP: {
-- 
cgit v1.2.3


From 0b0356be114ada8ecf4cdec69eae8dd8affce81d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Mon, 23 Nov 2009 20:07:40 +0100
Subject: fixed pod (RT #51971)

---
 lib/Schedule/Cron.pm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 7fe016b..eec7589 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -636,8 +636,8 @@ sub delete_entry
 =item $cron->update_entry($idx,$entry)
 
 Updates the entry with index C<$idx>. C<$entry> is a hash ref as descibed in
-C<list_entries()> and must contain at least a value C<$entry->{time}>. If no
-C<$entry->{dispatcher}> is given, then the default dispatcher is used.  This
+C<list_entries()> and must contain at least a value C<$entry-E<gt>{time}>. If no
+C<$entry-E<gt>{dispatcher}> is given, then the default dispatcher is used.  This
 method returns the old entry on success, C<undef> otherwise.
 
 =cut 
-- 
cgit v1.2.3


From 8fe3d90c47d51d8726847356ff441b50e226d1e7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Thu, 21 Jan 2010 10:44:30 +0100
Subject: Fixed RT#53732

---
 CHANGES            | 3 +++
 Makefile.PL        | 2 +-
 t/execution_time.t | 2 +-
 3 files changed, 5 insertions(+), 2 deletions(-)

diff --git a/CHANGES b/CHANGES
index c5b66f5..608cbaa 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,6 @@
+1.00
+- Fixed some minor bugs
+
 0.99
 
 - Fixed issue when switching back DST which can result into amok 
diff --git a/Makefile.PL b/Makefile.PL
index de5f8ab..564cfe0 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -6,7 +6,7 @@ WriteMakefile
    VERSION_FROM => "lib/Schedule/Cron.pm",
    ($] >= 5.005
     ? (ABSTRACT   => 'Cron-like scheduler for Perl subroutines',
-         AUTHOR     => 'Roland Huss (roland@cpan.org)')
+       AUTHOR     => 'Roland Huss (roland@cpan.org)')
     : ()),
    ($ExtUtils::MakeMaker::VERSION >= 6.3002 ?
     ('LICENSE'		=> 'perl', ) : ()),
diff --git a/t/execution_time.t b/t/execution_time.t
index 4ff8a79..84bd8dd 100644
--- a/t/execution_time.t
+++ b/t/execution_time.t
@@ -20,7 +20,6 @@ my $time;
 my $skip = 0;
 while (defined($_=<DATA>) && $_ !~ /^end/i) {
   chomp;
-  next if $skip;
   if (/^Reftime:\s*(.*)$/) {
       $time = $1;
       $time =~ s/\#.*$//;
@@ -35,6 +34,7 @@ while (defined($_=<DATA>) && $_ !~ /^end/i) {
       $skip = 0;
       next;
   }
+  next if $skip;
   s/^\s*(.*)\s*/$1/;
   next if /^\#/ || /^$/;
   my @args = split(/\s+/,$_,6);
-- 
cgit v1.2.3


From ac324cba4e7553660e7a89865e6b0348b2463bdc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Mon, 22 Mar 2010 08:20:25 +0100
Subject: Further patches, preparations for 1.00_1

---
 CHANGES              |  7 ++++++-
 lib/Schedule/Cron.pm | 37 ++++++++++++++++++++++++++++++++-----
 2 files changed, 38 insertions(+), 6 deletions(-)

diff --git a/CHANGES b/CHANGES
index 608cbaa..112e64b 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,10 @@
 1.00
-- Fixed some minor bugs
+- Fix for RT #54692 occured when removing an entry
+- Try to workaround #55741 (a perl bug occuring when modyfing 
+  global hashes in an event handler)
+- Fixed RT #50325 which could cause an infinite loop when calculating
+  the next execution time
+- Further bug fixes.
 
 0.99
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index eec7589..a28f235 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -125,12 +125,13 @@ my @LOWMAP = (
 sub REAPER {
     if ($HAS_POSIX)
     {
-        # Only on platforms supporting POSIX semantisc
         foreach my $pid (keys %STARTEDCHILD) {
-            my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
-            if ($res > 0) {
-                # We reaped a truly running process
-                delete $STARTEDCHILD{$pid};
+            if ($STARTEDCHILD{$pid}) {
+                my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
+                if ($res > 0) {
+                    # We reaped a truly running process
+                    $STARTEDCHILD{$pid} = 0;
+                }
             }
         }
     } 
@@ -143,6 +144,17 @@ sub REAPER {
     }
 }
 
+# Cleaning is done in extrac method called from the main 
+# process in order to avoid event handlers modifying this
+# global hash which can leed to memory errors
+# See #55741 on rt.cpan.org for more details on this
+# This method is called in strategic places.
+sub _cleanup_process_list {
+    for my $k (keys %STARTEDCHILD) {
+        delete $STARTEDCHILD{$k} unless $STARTEDCHILD{$_};
+    }
+}
+
 =item $cron = new Schedule::Cron($dispatcher,[extra args])
 
 Creates a new C<Cron> object.  C<$dispatcher> is a reference to a subroutine,
@@ -625,6 +637,20 @@ sub delete_entry
     if ($idx <= $#{$self->{time_table}})
     {
         $self->{entries_changed} = 1;
+
+        # Remove entry from $self->{map} which 
+        # remembers the index in the timetable by name (==id)
+        # and update all larger indexes appropriately
+        # Fix for #54692
+        my $map = $self->{map};
+        foreach my $key (keys %{$map}) {
+            if ($map->{$key} > $idx) {
+                $map->{$key}--;
+            } elsif ($map->{$key} == $idx) {
+                delete $map->{$key};
+            }
+        }
+        
         return splice @{$self->{time_table}},$idx,1;
     }
     else
@@ -772,6 +798,7 @@ sub run
             }
 
             $self->_execute($index,$cfg);
+            $self->_cleanup_process_list;
 
             if ($self->{entries_changed}) {
                dbg "rebuilding queue";
-- 
cgit v1.2.3


From 6047d974496081360e3751c8e89b09e8706190f0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Mon, 22 Mar 2010 08:24:24 +0100
Subject: Small fix.

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index a28f235..bbc3765 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -151,7 +151,7 @@ sub REAPER {
 # This method is called in strategic places.
 sub _cleanup_process_list {
     for my $k (keys %STARTEDCHILD) {
-        delete $STARTEDCHILD{$k} unless $STARTEDCHILD{$_};
+        delete $STARTEDCHILD{$k} unless $STARTEDCHILD{$k};
     }
 }
 
-- 
cgit v1.2.3


From 7e7512b7bc231dbb36bd2e61ee7fb02b7ff6c94f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Sun, 4 Apr 2010 18:47:33 +0200
Subject: Insert minor enhancement report for RT#55741

---
 META.yml             | 8 ++++----
 lib/Schedule/Cron.pm | 1 +
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/META.yml b/META.yml
index b64ab3d..7d97c64 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 0.99
+version: 1.00_1
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -18,12 +18,12 @@ recommends:
   ioctl.ph: 0
   sys::ioctl.ph: 0
 configure_requires:
-  Module::Build: 0.34
+  Module::Build: 0.35
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 0.99
-generated_by: Module::Build version 0.34
+    version: 1.00_1
+generated_by: Module::Build version 0.35
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
   version: 1.4
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index bbc3765..0d1c002 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -123,6 +123,7 @@ my @LOWMAP = (
              );
 
 sub REAPER {
+    local ($!,%!);
     if ($HAS_POSIX)
     {
         foreach my $pid (keys %STARTEDCHILD) {
-- 
cgit v1.2.3


From b7ec09e55d49bbad3f4c382f548955e2d4696c83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Mon, 5 Apr 2010 09:08:05 +0200
Subject: doc fixes

---
 lib/Schedule/Cron.pm | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 0d1c002..2d9c4f4 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -145,10 +145,10 @@ sub REAPER {
     }
 }
 
-# Cleaning is done in extrac method called from the main 
+# Cleaning is done in extra method called from the main 
 # process in order to avoid event handlers modifying this
-# global hash which can leed to memory errors
-# See #55741 on rt.cpan.org for more details on this
+# global hash which can lead to memory errors.
+# See #55741 on rt.cpan.org for more details on this.
 # This method is called in strategic places.
 sub _cleanup_process_list {
     for my $k (keys %STARTEDCHILD) {
-- 
cgit v1.2.3


From b8499ca6e93f95e4103d25d8ec8b58bd55835dab Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Fri, 14 May 2010 10:08:37 +0200
Subject: Final touches for release 1.00

---
 CHANGES              | 5 +++--
 ChangeLog            | 7 +++++++
 META.yml             | 4 ++--
 lib/Schedule/Cron.pm | 2 +-
 4 files changed, 13 insertions(+), 5 deletions(-)

diff --git a/CHANGES b/CHANGES
index 112e64b..2ad35bf 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,7 +1,8 @@
 1.00
+
 - Fix for RT #54692 occured when removing an entry
-- Try to workaround #55741 (a perl bug occuring when modyfing 
-  global hashes in an event handler)
+- Fixed #55741 with help from Clinton Gormley (a perl bug occuring when 
+  modyfing global hashes in an event handler)
 - Fixed RT #50325 which could cause an infinite loop when calculating
   the next execution time
 - Further bug fixes.
diff --git a/ChangeLog b/ChangeLog
index 6f6f572..7586a33 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,10 @@
+2010-05-14  Roland Huss  <roland@consol.de>
+
+	* Released Version 1.00. This is considered to be the final 
+	  release. After 10+ years, Schedule::Cron is now feature complete, 
+	  only bug fixes might lead to an additional release. Thanks for
+	  your patience ;-)
+
 2009-09-12  Roland Huss  <roland@consol.de>
 
 	* Released Version 0.99
diff --git a/META.yml b/META.yml
index 7d97c64..8614d15 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 1.00_1
+version: 1.00
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -22,7 +22,7 @@ configure_requires:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.00_1
+    version: 1.00
 generated_by: Module::Build version 0.35
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 2d9c4f4..a6939fc 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.00_1";
+$VERSION = "1.00";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From bd1bbaed8c729ae95cf51d5728d00c221e858d67 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@tichny.org>
Date: Fri, 14 May 2010 19:38:44 +0200
Subject: Fixes for #56926 added.

---
 CHANGES              |  5 +++++
 lib/Schedule/Cron.pm | 43 ++++++++++++++++++++++---------------------
 t/delete_entry.t     | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 73 insertions(+), 21 deletions(-)
 create mode 100644 t/delete_entry.t

diff --git a/CHANGES b/CHANGES
index 2ad35bf..0c4886c 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,8 @@
+1.01
+
+- Fix for RT #56926 which causes systems without SIGCHLD to exit on
+  after 64 forked processes
+
 1.00
 
 - Fix for RT #54692 occured when removing an entry
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index a6939fc..e1817e0 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.00";
+$VERSION = "1.01_1";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -124,33 +124,35 @@ my @LOWMAP = (
 
 sub REAPER {
     local ($!,%!);
-    if ($HAS_POSIX)
-    {
-        foreach my $pid (keys %STARTEDCHILD) {
-            if ($STARTEDCHILD{$pid}) {
-                my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
-                if ($res > 0) {
-                    # We reaped a truly running process
-                    $STARTEDCHILD{$pid} = 0;
-                }
-            }
+    my $kid;
+    do {
+        # Only on POSIX systems the wait will return immediately only 
+        # if there are no finished child processes. Simple 'wait' will
+        # wait blocking on childs.
+        $kid = $HAS_POSIX ? waitpid(-1, WNOHANG) : wait;
+        if ($kid > 0 && defined $STARTEDCHILD{$kid}) {
+            # We don't delete the hash entry here to avoid an issue
+            # when modifying a global hash from multiple threads
+            $STARTEDCHILD{$kid} = 0;
         }
-    } 
-    else
-    {
-        my $waitedpid = 0;
-        while($waitedpid != -1) {
-            $waitedpid = wait;
-        }
-    }
+    } while ($kid > 0);
 }
 
 # Cleaning is done in extra method called from the main 
 # process in order to avoid event handlers modifying this
 # global hash which can lead to memory errors.
-# See #55741 on rt.cpan.org for more details on this.
+# See RT #55741 for more details on this.
 # This method is called in strategic places.
 sub _cleanup_process_list {
+    # Cleanup processes even on those systems, where the SIGCHLD is not 
+    # propagated. Only do this for POSIX, otherwise this call would block 
+    # until all child processes would have been finished.
+    # See RT #56926 for more details.
+    &REAPER() if $HAS_POSIX;
+
+    # Delete entries from this global hash only from within the main
+    # thread/process. Hence, this method must not be called from within 
+    # a signalhandler    
     for my $k (keys %STARTEDCHILD) {
         delete $STARTEDCHILD{$k} unless $STARTEDCHILD{$k};
     }
@@ -651,7 +653,6 @@ sub delete_entry
                 delete $map->{$key};
             }
         }
-        
         return splice @{$self->{time_table}},$idx,1;
     }
     else
diff --git a/t/delete_entry.t b/t/delete_entry.t
new file mode 100644
index 0000000..b6256e8
--- /dev/null
+++ b/t/delete_entry.t
@@ -0,0 +1,46 @@
+#!/usr/bin/perl
+#
+
+# =============================================
+# Adapted from patch provided with RT #54692
+
+use Test::More tests => 3;
+
+use Schedule::Cron;
+use Data::Dumper;
+use strict;
+use warnings;
+
+$| = 1;
+
+#System::Proc::Simple->debug(0);
+
+my $cron = new Schedule::Cron(
+                              \&dispatcher,
+                              nofork => 1,
+                              catch => 0,
+                             );
+
+$cron->add_entry("* * * * * *", 'Test1');
+$cron->add_entry("* * * * * *", 'Test2');
+
+my $e_idx = $cron->check_entry('Test2');
+$cron->delete_entry($e_idx);
+
+$cron->add_entry("* * * * * *", 'Test3');
+
+foreach my $e_name (qw/Test1 Test2 Test3/) {
+  my $e_idx = $cron->check_entry($e_name);
+  if (defined($e_idx)) {
+    my $entry = $cron->get_entry($e_idx);
+    is($entry->{args}->[0],$e_name,"$e_name defined");
+  }
+  else {
+      is($e_name,"Test2","Test2 not found");
+  }
+}
+
+sub dispatcher {
+  my $name = shift;
+  printf "Running %s.\n", $name;
+}
-- 
cgit v1.2.3


From ac01e90e28fb673bdf56664d7b4f8116c840fe68 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 11:05:42 +0200
Subject: Some documentation fixes.

---
 META.yml             |  4 ++--
 lib/Schedule/Cron.pm | 25 +++++++++++++++++--------
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/META.yml b/META.yml
index 8614d15..8b1695c 100644
--- a/META.yml
+++ b/META.yml
@@ -1,6 +1,6 @@
 ---
 name: Schedule-Cron
-version: 1.00
+version: 1.01_1
 author:
   - Roland Huss (roland@cpan.org)
 abstract: cron-like scheduler for Perl subroutines
@@ -22,7 +22,7 @@ configure_requires:
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.00
+    version: 1.01_1
 generated_by: Module::Build version 0.35
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index e1817e0..b16f808 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -125,17 +125,24 @@ my @LOWMAP = (
 sub REAPER {
     local ($!,%!);
     my $kid;
-    do {
-        # Only on POSIX systems the wait will return immediately only 
-        # if there are no finished child processes. Simple 'wait' will
-        # wait blocking on childs.
+    do 
+    {
+        # Only on POSIX systems the wait will return immediately 
+        # if there are no finished child processes. Simple 'wait'
+        # waits blocking on childs.
         $kid = $HAS_POSIX ? waitpid(-1, WNOHANG) : wait;
-        if ($kid > 0 && defined $STARTEDCHILD{$kid}) {
+        if ($kid > 0 && defined $STARTEDCHILD{$kid}) 
+        {
             # We don't delete the hash entry here to avoid an issue
             # when modifying a global hash from multiple threads
             $STARTEDCHILD{$kid} = 0;
         }
     } while ($kid > 0);
+
+    # Note to myself: Is the %STARTEDCHILD hash really necessary if we use -1
+    # for waiting (i.e. for waiting on any child ?). In the current
+    # implementation, %STARTEDCHILD is not used at all. It would be only 
+    # needed if we iterate over it to wait on pids specifically.
 }
 
 # Cleaning is done in extra method called from the main 
@@ -143,7 +150,8 @@ sub REAPER {
 # global hash which can lead to memory errors.
 # See RT #55741 for more details on this.
 # This method is called in strategic places.
-sub _cleanup_process_list {
+sub _cleanup_process_list 
+{
     # Cleanup processes even on those systems, where the SIGCHLD is not 
     # propagated. Only do this for POSIX, otherwise this call would block 
     # until all child processes would have been finished.
@@ -153,7 +161,8 @@ sub _cleanup_process_list {
     # Delete entries from this global hash only from within the main
     # thread/process. Hence, this method must not be called from within 
     # a signalhandler    
-    for my $k (keys %STARTEDCHILD) {
+    for my $k (keys %STARTEDCHILD) 
+    {
         delete $STARTEDCHILD{$k} unless $STARTEDCHILD{$k};
     }
 }
@@ -1702,7 +1711,7 @@ Sorry for that.
 
 =head1 LICENSE
 
-Copyright 1999-2009 Roland Huss.
+Copyright 1999-2010 Roland Huss.
 
 This library is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
-- 
cgit v1.2.3


From 21d93f698d5bed23d5361a78eb0a019aed29d639 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 15:30:32 +0200
Subject: Applied all open patches and reverted REAPER handling to dedicated
 waiting on known child PIDs.

---
 CHANGES              |   4 +
 ChangeLog            |   6 ++
 MANIFEST             |   1 +
 Makefile.PL          |   3 +-
 lib/Schedule/Cron.pm | 228 ++++++++++++++++++++++++++++++++++++++-------------
 5 files changed, 186 insertions(+), 56 deletions(-)

diff --git a/CHANGES b/CHANGES
index 0c4886c..be4f533 100644
--- a/CHANGES
+++ b/CHANGES
@@ -2,6 +2,10 @@
 
 - Fix for RT #56926 which causes systems without SIGCHLD to exit on
   after 64 forked processes
+- Patch for Makefile.PL applied which seems to have problems after the 
+  reorganisation of the directory layout (RT #57914)
+- Fix for RT #63089 which left over a time-window of 1 sec where
+  Schedule::Cron could run havoc.
 
 1.00
 
diff --git a/ChangeLog b/ChangeLog
index 7586a33..16c5363 100644
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,3 +1,9 @@
+2011-06-02  Roland Huss  <roland@consol.de>
+
+	* lib/Schedule/Cron.pm: Applied jumbo patch from RT #68533.
+	
+	* (_update_queue): fixed DST detection (RT #63089)	
+	
 2010-05-14  Roland Huss  <roland@consol.de>
 
 	* Released Version 1.00. This is considered to be the final 
diff --git a/MANIFEST b/MANIFEST
index 46736a9..9b923bf 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -21,3 +21,4 @@ t/pretty_print_args.t
 t/sighandler.t
 t/startup.t
 t/test.crontab
+t/delete_entry.t
diff --git a/Makefile.PL b/Makefile.PL
index 564cfe0..0af5e60 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -6,7 +6,8 @@ WriteMakefile
    VERSION_FROM => "lib/Schedule/Cron.pm",
    ($] >= 5.005
     ? (ABSTRACT   => 'Cron-like scheduler for Perl subroutines',
-       AUTHOR     => 'Roland Huss (roland@cpan.org)')
+       AUTHOR     => 'Roland Huss (roland@cpan.org)',
+       PL_FILES => {})
     : ()),
    ($ExtUtils::MakeMaker::VERSION >= 6.3002 ?
     ('LICENSE'		=> 'perl', ) : ()),
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b16f808..0e62d94 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.01_1";
+$VERSION = "1.01_2";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -122,7 +122,47 @@ my @LOWMAP = (
               {},
              );
 
+
+# Currently, there are two ways for reaping. One, which only waits explicitely
+# on PIDs it forked on its own, and one which waits on all PIDs (even on those
+# it doesn't forked itself). The later has been proved to work on Win32 with
+# the 64 threads limit (RT #56926), but not when one creates forks on ones
+# one. The specific reaper works for RT #55741.
+
+# It tend to use the specific one, if it also resolves RT #56926. Both are left
+# here for reference until a decision has been done for 1.01
+
 sub REAPER {
+    &_reaper_all();
+}
+
+# Specific reaper
+sub _reaper_specific {
+    local ($!,%!);
+    if ($HAS_POSIX)
+    {
+        foreach my $pid (keys %STARTEDCHILD) {
+            if ($STARTEDCHILD{$pid}) {
+                my $res = $HAS_POSIX ? waitpid($pid, WNOHANG) : waitpid($pid,0);
+                if ($res > 0) {
+                    # We reaped a truly running process
+                    $STARTEDCHILD{$pid} = 0;
+                    dbg "Reaped child $res" if $DEBUG;
+                }
+            }
+        }
+    } 
+    else
+    {
+        my $waitedpid = 0;
+        while($waitedpid != -1) {
+            $waitedpid = wait;
+        }
+    }
+}
+
+# Catch all reaper
+sub _reaper_all {
     local ($!,%!);
     my $kid;
     do 
@@ -131,13 +171,15 @@ sub REAPER {
         # if there are no finished child processes. Simple 'wait'
         # waits blocking on childs.
         $kid = $HAS_POSIX ? waitpid(-1, WNOHANG) : wait;
-        if ($kid > 0 && defined $STARTEDCHILD{$kid}) 
+        print "Kid: $kid\n";
+        if ($kid != 0 && $kid != -1 && defined $STARTEDCHILD{$kid}) 
         {
             # We don't delete the hash entry here to avoid an issue
-            # when modifying a global hash from multiple threads
+            # when modifyinga global hash from multiple threads
             $STARTEDCHILD{$kid} = 0;
+            dbg "Reaped child $kid" if $DEBUG;
         }
-    } while ($kid > 0);
+    } while ($kid != 0 && $kid != -1);
 
     # Note to myself: Is the %STARTEDCHILD hash really necessary if we use -1
     # for waiting (i.e. for waiting on any child ?). In the current
@@ -152,11 +194,15 @@ sub REAPER {
 # This method is called in strategic places.
 sub _cleanup_process_list 
 {
+    my ($self, $cfg) = @_;
+    
     # Cleanup processes even on those systems, where the SIGCHLD is not 
     # propagated. Only do this for POSIX, otherwise this call would block 
     # until all child processes would have been finished.
     # See RT #56926 for more details.
-    &REAPER() if $HAS_POSIX;
+
+    # Do not cleanup if nofork because jobs that fork will do their own reaping.
+    &REAPER() if $HAS_POSIX && !$cfg->{nofork};
 
     # Delete entries from this global hash only from within the main
     # thread/process. Hence, this method must not be called from within 
@@ -205,6 +251,11 @@ where each jobs gets its own process and hence a B<copy> of the process space,
 independent of each other job and the main process. This is due to the nature
 of the  C<fork> system call. 
 
+=item nostatus =>  1
+
+Do not update status in $0.  Set this if you don't want ps to reveal the internals
+of your application, including job argument lists.  Default is 0 (update status).
+
 =item skip => 1
 
 Skip any pending jobs whose time has passed. This option is only useful in
@@ -255,13 +306,51 @@ purposes for example like in the following code snippet:
   
    my $cron = new Schedule::Cron(.... , log => $log_method);
 
+=item loglevel => <-1,0,1,2>
+
+Restricts logging to the specified severity level or below.  Use 0 to have all
+messages generated, 1 for only warnings and errors and 2 for errors only.
+Default is 0 (all messages).  A loglevel of -1 (debug) will include job
+argument lists (also in $0) in the job start message logged with a level of 0
+or above. You may have security concerns with this. Unless you are debugging,
+use 0 or higher. A value larger than 2 will disable logging completely.
+
+Although you can filter in your log routine, generating the messages can be
+expensive, for example if you pass arguments pointing to large hashes.  Specifying
+a loglevel avoids formatting data that your routine would discard.
+
 =item processprefix => <name>
 
 Cron::Schedule sets the process' name (i.e. C<$0>) to contain some informative
 messages like when the next job executes or with which arguments a job is
 called. By default, the prefix for this labels is C<Schedule::Cron>. With this
 option you can set it to something different. You can e.g. use C<$0> to include
-the original process name.
+the original process name.  You can inhibit this with the C<nostatus> option, and
+prevent the argument display by setting C<loglevel> to zero or higher.
+
+=item sleep => \&hook
+
+If specified, &hook will be called instead of sleep(), with the time to sleep
+in seconds as first argument and the Schedule::Cron object as second.  This hook
+allows you to use select() instead of sleep, so that you can handle IO, for
+example job requests from a network connection.
+
+e.g.
+
+  $cron->run( { sleep => \&sleep_hook, nofork => 1 } );
+
+  sub sleep_hook {
+    my ($time, $cron) = @_;
+
+    my ($rin, $win, $ein) = ('','','');
+    my ($rout, $wout, $eout);
+    vec($rin, fileno(STDIN), 1) = 1;
+    my ($nfound, $ttg) = select($rout=$rin, $wout=$win, $eout=$ein, $time);
+    if ($nfound) {
+	   handle_io($rout, $wout, $eout);
+    }
+    return;
+}
 
 =back
 
@@ -528,7 +617,7 @@ sub add_entry
         {
             die "You have to provide a simple scalar if using eval" if (ref($args));
             my $orig_args = $args;
-            dbg "Evaled args ",Dumper($args);
+            dbg "Evaled args ",Dumper($args) if $DEBUG;
             $args = [ eval $args ];
             die "Cannot evaluate args (\"$orig_args\")"
               if $@;
@@ -730,7 +819,7 @@ If running in daemon mode, name the optional file, in which the process id of
 the scheduler process should be written. By default, no PID File will be
 created.
 
-=item nofork, skip, catch, log
+=item nofork, skip, catch, log, loglevel, nostatus, sleep
 
 See C<new()> for a description of these configuration parameters, which can be
 provided here as well. Note, that the options given here overrides those of the
@@ -758,25 +847,36 @@ sub run
     $cfg = { %{$self->{cfg}}, %$cfg }; # Merge in global config;
 
     my $log = $cfg->{log};
+    my $loglevel = $cfg->{loglevel};
+    $loglevel = 0 unless defined $loglevel;
+    my $sleeper = $cfg->{sleep};
 
-    $self->_build_initial_queue;
+    $self->_rebuild_queue;
     delete $self->{entries_changed};
     die "Nothing in schedule queue" unless @{$self->{queue}};
     
     # Install reaper now.
-    my $old_child_handler = $SIG{'CHLD'};
-    $SIG{'CHLD'} = sub {
-        &REAPER();
-        if ($old_child_handler && ref $old_child_handler eq 'CODE')
-        {
-            &$old_child_handler();
-        }
-    };
-
-    my $mainloop = sub 
-    {
-        while (42) 
+    unless ($cfg->{nofork}) {
+        my $old_child_handler = $SIG{'CHLD'};
+        $SIG{'CHLD'} = sub {
+            &REAPER();
+            if ($old_child_handler && ref $old_child_handler eq 'CODE')
+            {
+                &$old_child_handler();
+            }
+        };
+    }
+    
+    my $mainloop = sub { 
+      MAIN:
+        while (42)          
         {
+            unless (@{$self->{queue}}) # Queue length
+            { 
+                # Last job deleted itself, or we were run with no entries.
+                # We can't return, so throw an exception - perhaps somone will catch.
+                die "No more jobs to run\n";
+            }
             my ($index,$time) = @{shift @{$self->{queue}}};
             my $now = time;
             my $sleep = 0;
@@ -785,7 +885,7 @@ sub run
                 if ($cfg->{skip})
                 {
                     $log->(0,"Schedule::Cron - Skipping job $index")
-                      if $log;
+                      if $log && $loglevel <= 0;
                     $self->_update_queue($index);
                     next;
                 }
@@ -796,24 +896,36 @@ sub run
             {
                 $sleep = $time - $now;
             }
-            $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time));
+            $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time)) unless $cfg->{nostatus};
             if (!$time) {
                 die "Internal: No time found, self: ",$self->{queue},"\n" unless $time;
             }
 
-            dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")";
+            dbg "R: sleep = $sleep | ",scalar(localtime($time))," (",scalar(localtime($now)),")" if $DEBUG;
+
             while ($sleep > 0) 
             {
-                sleep($sleep);
+                if ($sleeper) 
+                {
+                    $sleeper->($sleep,$self);
+                    if ($self->{entries_changed})
+                    {
+                        $self->_rebuild_queue;
+                        delete $self->{entries_changed};
+                        redo MAIN;
+                    }
+                } else {
+                    sleep($sleep);
+                }
                 $sleep = $time - time;
             }
 
             $self->_execute($index,$cfg);
-            $self->_cleanup_process_list;
+            $self->_cleanup_process_list($cfg);
 
             if ($self->{entries_changed}) {
-               dbg "rebuilding queue";
-               $self->_build_initial_queue;
+               dbg "rebuilding queue" if $DEBUG;
+               $self->_rebuild_queue;
                delete $self->{entries_changed};
             } else {
                $self->_update_queue($index);
@@ -878,7 +990,7 @@ sub run
             }
             open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
             
-            $0 = $self->_get_process_prefix()." MainLoop";
+            $0 = $self->_get_process_prefix()." MainLoop" unless $cfg->{nostatus};
             &$mainloop();
         }
     } 
@@ -1040,7 +1152,7 @@ sub get_next_execution_time
       $expanded[4] = \@bak;
       $expanded[2] = [ '*' ];
       my $t2 = $self->_calc_time($now,\@expanded);
-      dbg "MDay : ",scalar(localtime($t1))," -- WDay : ",scalar(localtime($t2));
+      dbg "MDay : ",scalar(localtime($t1))," -- WDay : ",scalar(localtime($t2)) if $DEBUG;
       return $t1 < $t2 ? $t1 : $t2;
   } 
   else 
@@ -1056,7 +1168,7 @@ sub get_next_execution_time
 
 # Build up executing queue and delete any
 # existing entries
-sub _build_initial_queue 
+sub _rebuild_queue 
 { 
     my $self = shift;
     $self->{queue} = [ ];
@@ -1091,13 +1203,14 @@ sub _execute
 
 
   my $log = $cfg->{log};
+  my $loglevel = $cfg->{loglevel} || 0;
 
   unless ($cfg->{nofork})
   {
-      if ($pid = fork) 
+      if ($pid = fork)
       {
           # Parent
-          $log->(0,"Schedule::Cron - Forking child PID $pid") if $log;
+          $log->(0,"Schedule::Cron - Forking child PID $pid") if $log && $loglevel <= 0;
           # Register PID
           $STARTEDCHILD{$pid} = 1;
           return;
@@ -1117,12 +1230,13 @@ sub _execute
   }
 
 
-  my $args_label = @args ? "with (".join(",",$self->_format_args(@args)).")" : "";
-  $0 = $self->_get_process_prefix()." Dispatched with $args_label"
-    unless $cfg->{nofork};
-  $log->(0,"Schedule::Cron - Starting job $index $args_label")
-    if $log;
-
+  if ($log && $loglevel <= 0 || !$cfg->{nofork} && !$cfg->{nostatus}) {
+      my $args_label = (@args && $loglevel <= -1) ? " with (".join(",",$self->_format_args(@args)).")" : "";
+      $0 = $self->_get_process_prefix()." Dispatched job $index$args_label"
+        unless $cfg->{nofork} || $cfg->{nostatus};
+      $log->(0,"Schedule::Cron - Starting job $index$args_label")
+        if $log && $loglevel <= 0;
+  }
   my $dispatch_result;
   if ($cfg->{catch})
   {
@@ -1134,7 +1248,7 @@ sub _execute
       if ($@)
       {
           $log->(2,"Schedule::Cron - Error within job $index: $@")
-            if $log;
+            if $log && $loglevel <= 2;
       }
   }
   else
@@ -1153,14 +1267,15 @@ sub _execute
           if ($@)
           {
               $log->(2,"Schedule::Cron - Error while calling after_job callback with retval = $dispatch_result: $@")
-                if $log;
+                if $log && $loglevel <= 2;
           }
       } else {
-          $log->(2,"Schedule::Cron - Invalid after_job callback, it's not a code ref (but ",$job,")");
+          $log->(2,"Schedule::Cron - Invalid after_job callback, it's not a code ref (but ",$job,")")
+            if $log && $loglevel <= 2;
       }
   }
 
-  $log->(0,"Schedule::Cron - Finished job $index") if $log;
+  $log->(0,"Schedule::Cron - Finished job $index") if $log && $loglevel <= 0;
   exit unless $cfg->{nofork};
 }
 
@@ -1175,15 +1290,15 @@ sub _update_queue
     # Check, whether next execution time is *smaller* than the current time.
     # This can happen during DST backflip:
     my $now = time;
-    if ($new_time < $now) {
-        dbg "Adjusting time calculation because of DST back flip (new_time - now = ",$new_time - $now,")";
+    if ($new_time <= $now) {
+        dbg "Adjusting time calculation because of DST back flip (new_time - now = ",$new_time - $now,")" if $DEBUG;
         # We are adding hours as long as our target time is in the future
-        while ($new_time < $now) {
+        while ($new_time <= $now) {
             $new_time += 3600;
         }
     }
 
-    dbg "Updating Queue: ",scalar(localtime($new_time));
+    dbg "Updating Queue: ",scalar(localtime($new_time)) if $DEBUG;
     $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
     #  dbg "Queue now: ",Dumper($self->{queue});
 }
@@ -1217,7 +1332,7 @@ sub _calc_time
     # Airbag...
     while ($dest_year <= $now_year + 1) 
     { 
-        dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday";
+        dbg "Parsing $dest_hour:$dest_min:$dest_sec $dest_year/$dest_mon/$dest_mday" if $DEBUG;
         
         # Check month:
         if ($expanded->[3]->[0] ne '*') 
@@ -1248,7 +1363,7 @@ sub _calc_time
                         $dest_mon = 1;
                         $dest_year++;
                     }
-                    dbg "Backtrack mday: $dest_mday/$dest_mon/$dest_year";
+                    dbg "Backtrack mday: $dest_mday/$dest_mon/$dest_year" if $DEBUG;
                     next;
                 }
             }
@@ -1273,9 +1388,9 @@ sub _calc_time
             $mon++;
             $year += 1900;
             
-            dbg "Calculated $mday/$mon/$year for weekday ",$WDAYS[$dest_wday];
+            dbg "Calculated $mday/$mon/$year for weekday ",$WDAYS[$dest_wday] if $DEBUG;
             if ($mon != $dest_mon || $year != $dest_year) {
-                dbg "backtracking";
+                dbg "backtracking" if $DEBUG;
                 $dest_mon = $mon;
                 $dest_year = $year;
                 $dest_mday = 1;
@@ -1393,7 +1508,7 @@ sub _calc_time
         # We did it !!
         my $date = sprintf("%2.2d:%2.2d:%2.2d %4.4d/%2.2d/%2.2d",
                            $dest_hour,$dest_min,$dest_sec,$dest_year,$dest_mon,$dest_mday);
-        dbg "Next execution time: $date ",$WDAYS[$dest_wday];
+        dbg "Next execution time: $date ",$WDAYS[$dest_wday] if $DEBUG;
         my $result = parsedate($date, VALIDATE => 1);
         # Check for a valid date
         if ($result)
@@ -1460,6 +1575,9 @@ sub _get_process_prefix {
 
 # our very own debugging routine
 # ('guess everybody has its own style ;-)
+# Callers check $DEBUG on the critical path to save the computes
+# used to produce expensive arguments.  Omitting those would be
+# functionally correct, but rather wasteful.
 sub dbg  
 {
   if ($DEBUG) 
@@ -1681,8 +1799,8 @@ sub _verify_expanded_cron_entry {
 
 Daylight saving occurs typically twice a year: In the first switch, one hour is
 skipped. Any job which which triggers in this skipped hour will be fired in the
-next hour. So, when the DST switch goes from 2:00 to 3:00 a job would is
-scheduled for 2:43, then it will be executed at 3:43.
+next hour. So, when the DST switch goes from 2:00 to 3:00 a job which is
+scheduled for 2:43 will be executed at 3:43.
 
 For the reverse backwards switch later in the year, the behaviour is
 undefined. Two possible behaviours can occur: For jobs triggered in short
@@ -1711,7 +1829,7 @@ Sorry for that.
 
 =head1 LICENSE
 
-Copyright 1999-2010 Roland Huss.
+Copyright 1999-2011 Roland Huss.
 
 This library is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
-- 
cgit v1.2.3


From 64b1dfde15a4014a69cd8759ff9e3a512022039a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 15:33:50 +0200
Subject: Added fixes to CHANGES.

---
 CHANGES | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/CHANGES b/CHANGES
index be4f533..525f15e 100644
--- a/CHANGES
+++ b/CHANGES
@@ -6,6 +6,9 @@
   reorganisation of the directory layout (RT #57914)
 - Fix for RT #63089 which left over a time-window of 1 sec where
   Schedule::Cron could run havoc.
+- Fixes for RT #68530 ("Exposing too much information..."), #68450
+  ("Crash scheduling empty queue") and #68533 ("Thou shalt not REAP
+  what thou has not forked...") provided by tlhackque. Thanks a lot !
 
 1.00
 
-- 
cgit v1.2.3


From 9b3a0d32160df481e1a4df1102c5a0e5c860380d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 15:37:36 +0200
Subject: Tuned build.

---
 Build.PL |  8 ++------
 MANIFEST |  1 +
 META.yml | 37 +++++++++++++++++--------------------
 3 files changed, 20 insertions(+), 26 deletions(-)

diff --git a/Build.PL b/Build.PL
index 388c3e3..063a514 100644
--- a/Build.PL
+++ b/Build.PL
@@ -19,16 +19,12 @@ my $build = Module::Build->new
                       "Test::More" => "0",
                       "Test" => "0",
                      },                       
-   recommends => {
-                  "ioctl.ph" => 0,
-                  "sys::ioctl.ph" => 0,
-                  "Module::Build" => 0
-                 },
    keywords => [  "Cron", "Scheduler", "Job" ],
    provides => {
                 "Schedule::Cron" => {
                                file =>  "lib/Schedule/Cron.pm"
                               }
-               }
+               },
+   configure_requires => { 'Module::Build' => 0}
   );
 $build->create_build_script;
diff --git a/MANIFEST b/MANIFEST
index 9b923bf..5a7211f 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -22,3 +22,4 @@ t/sighandler.t
 t/startup.t
 t/test.crontab
 t/delete_entry.t
+META.json
diff --git a/META.yml b/META.yml
index 8b1695c..91d6828 100644
--- a/META.yml
+++ b/META.yml
@@ -1,29 +1,26 @@
 ---
-name: Schedule-Cron
-version: 1.01_1
+abstract: 'cron-like scheduler for Perl subroutines'
 author:
-  - Roland Huss (roland@cpan.org)
-abstract: cron-like scheduler for Perl subroutines
-license: perl
-resources:
-  license: http://dev.perl.org/licenses/
+  - 'Roland Huss (roland@cpan.org)'
 build_requires:
   Test: 0
   Test::More: 0
-requires:
-  Data::Dumper: 0
-  Time::ParseDate: 99.00
-recommends:
-  Module::Build: 0
-  ioctl.ph: 0
-  sys::ioctl.ph: 0
 configure_requires:
-  Module::Build: 0.35
-provides:
-  Schedule::Cron:
-    file: lib/Schedule/Cron.pm
-    version: 1.01_1
-generated_by: Module::Build version 0.35
+  Module::Build: 0
+dynamic_config: 1
+generated_by: 'Module::Build version 0.38, CPAN::Meta::Converter version 2.110580'
+license: perl
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
   version: 1.4
+name: Schedule-Cron
+provides:
+  Schedule::Cron:
+    file: lib/Schedule/Cron.pm
+    version: 1.01_2
+requires:
+  Data::Dumper: 0
+  Time::ParseDate: 99.00
+resources:
+  license: http://dev.perl.org/licenses/
+version: 1.01_2
-- 
cgit v1.2.3


From 9deae15f615a8c38e77bb554294296ab6d41e5c7 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 15:39:59 +0200
Subject: Additional comments.

---
 CHANGES | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/CHANGES b/CHANGES
index 525f15e..00621f5 100644
--- a/CHANGES
+++ b/CHANGES
@@ -9,7 +9,11 @@
 - Fixes for RT #68530 ("Exposing too much information..."), #68450
   ("Crash scheduling empty queue") and #68533 ("Thou shalt not REAP
   what thou has not forked...") provided by tlhackque. Thanks a lot !
-
+- New options:
+  * loglevel: Tuning of logoutput
+  * nostatus: Avoid setting $0 to next schedule time
+  * sleep: Custom sleep() function between two calls
+  
 1.00
 
 - Fix for RT #54692 occured when removing an entry
-- 
cgit v1.2.3


From 3ed245fc6da59ce2c8bc4e48e5236314b302f6fc Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 2 Jun 2011 21:58:14 +0200
Subject: Added examples, courtesy of Timothe Litt

---
 README                   |  20 ++-
 examples/cron.tab        |   3 +
 examples/custom_sleep.pl | 343 +++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 354 insertions(+), 12 deletions(-)
 create mode 100644 examples/cron.tab
 create mode 100644 examples/custom_sleep.pl

diff --git a/README b/README
index bf263f0..d413cdb 100644
--- a/README
+++ b/README
@@ -122,17 +122,13 @@ and further usage examples.
 REPORTING BUGS
 --------------
 
-This module  is still in alpha  stage, so I expect  probably some bugs
-showing  up. I.e.  the  calculation of  the next  execution time  of a
-specific  crontab  entry  might  fail in  some  obscure  circumstances
-(though I did what I could to test it thoroughly).
-
-If  you  meet  a bug  (say  hello  to  it  ;-),  please report  it  to
-roland@consol.de with  a subject like  "Schedule::Cron Bug-Report". In
-addition of a  problem description, please add a  short description of
-you OS, your  Perl version and the version  of Time::ParseDate you are
-using. If some of the provided tests fail, include the output of 'make
-test TEST_VERBOSE=1' as well.
+If  you  meet  a  bug  (say   hello  to  it  ;-),  open  a  ticket  at
+https://rt.cpan.org/Ticket/Create.html?Queue=Schedule-Cron.          
+
+In addition of  a problem description, please add  a short description
+of you  OS, your Perl version  and the version  of Time::ParseDate you
+are using.  If some of the  provided tests fail, include the output of
+'make test TEST_VERBOSE=1' as well.
 
 If you suspect,  that the date calculation of  the next execution time
 is buggy, please  use the following interactive command  to generate a
@@ -149,7 +145,7 @@ specified in  a format understood by  'parsedate' from Time::ParseDate
 LICENSE
 -------
 
-Copyright 1999-2009 Roland Huss.
+Copyright 1999-2011 Roland Huss.
 
 This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
diff --git a/examples/cron.tab b/examples/cron.tab
new file mode 100644
index 0000000..cb1f471
--- /dev/null
+++ b/examples/cron.tab
@@ -0,0 +1,3 @@
+# Sample cron tab used for custom_sleep.pl
+34 2 * * Mon "make_stats"
+43 8 * * Wed "Make Peace"
diff --git a/examples/custom_sleep.pl b/examples/custom_sleep.pl
new file mode 100644
index 0000000..cfc143a
--- /dev/null
+++ b/examples/custom_sleep.pl
@@ -0,0 +1,343 @@
+#!/usr/bin/perl
+
+# Copyright (c) 2011 Timothe Litt <litt at acm dot org>
+#
+# May be used on the same terms as Perl.
+
+# Sleep hook demo, showing how it enables a background thread
+# to provide a simple command interface to a daemon.
+
+=head1 custom_sleep - Demo for a custom 'sleep' function
+
+This example demonstrates the usage of the 'sleep' option
+for L<Schedule::Cron> with a custom sleep method which can 
+dynamically modify the crontab even inbetween to cron events.
+It provides a cron daemon which listens on a TCP port for commands. 
+
+Please note that this is an example only and should obviously not
+used for production !
+
+When started, this script will listen on port 65331 and will first
+ask for a password. Use 'Purfect' here. Then the following commands
+are available:
+
+   status                  -- Print internal job queue
+   add id "cron spec" name -- Add a sample jon which will bring "id: name" 
+                              each time "cron spec" fires
+   load /path/to/crontab   -- Load a crontab as with Schedule::Cron->load_crontab 
+   delete id               -- Delete job entry
+   quit                    -- Disconect
+
+A sample session looks like:
+
+First start the server:
+
+  ./custom_sleep.pl
+  Please wait while initialization is scheduled
+  Schedule::Cron - Starting job 0
+  Ready, my port is localhost::65331
+  Schedule::Cron - Finished job 0
+  Schedule::Cron - Starting job 5
+  Now: Periodic
+  Schedule::Cron - Finished job 5
+
+And then a client:
+
+  $ telnet localhost 65331
+  Trying 127.0.0.1...
+  Connected to localhost.localdomain (127.0.0.1).
+  Escape character is '^]'.
+  Password: Purfect
+  Password accepted
+
+  status
+  Job 0 0 0 1 1 * Next: Sun Jan 1 00:00:00 2012 - NewYear( )
+  End of job queue
+
+  load cron.tab
+  Loaded cron.tab
+
+  status
+  Job 1 34 2 * * Mon Next: Mon Jun 6 02:34:00 2011 - "make_stats"( )
+  Job 2 43 8 * * Wed Next: Wed Jun 8 08:43:00 2011 - "Make Peace"( )
+  Job 0 0 0 1 1 * Next: Sun Jan 1 00:00:00 2012 - NewYear( )
+  End of job queue
+
+  add Halloween "30 18 31 10 *" Pumpkin time
+  Added 30 18 31 10 *
+
+  add Today "11 15 * * *" Something to do
+  Added 11 15 * * *
+ 
+  add Now "*/2 * * * * 30" Periodic
+  Added */2 * * * * 30
+
+  status
+  Job 5 */2 * * * * 30 Next: Thu Jun 2 13:40:30 2011 - Now( Periodic )
+  Job 4 11 15 * * * Next: Thu Jun 2 15:11:00 2011 - Today( Something to do )
+  Job 1 34 2 * * Mon Next: Mon Jun 6 02:34:00 2011 - "make_stats"( )
+  Job 2 43 8 * * Wed Next: Wed Jun 8 08:43:00 2011 - "Make Peace"( )
+  Job 3 30 18 31 10 * Next: Mon Oct 31 18:30:00 2011 - Halloween( Pumpkin time )
+  Job 0 0 0 1 1 * Next: Sun Jan 1 00:00:00 2012 - NewYear( )
+  End of job queue
+ 
+  delete Today
+  Deleted Today
+  
+  status
+  Job 4 */2 * * * * 30 Next: Thu Jun 2 13:42:30 2011 - Now( Periodic )
+  Job 1 34 2 * * Mon Next: Mon Jun 6 02:34:00 2011 - "make_stats"( )
+  Job 2 43 8 * * Wed Next: Wed Jun 8 08:43:00 2011 - "Make Peace"( )
+  Job 3 30 18 31 10 * Next: Mon Oct 31 18:30:00 2011 - Halloween( Pumpkin time )
+  Job 0 0 0 1 1 * Next: Sun Jan 1 00:00:00 2012 - NewYear( )
+  End of job queue
+
+  q
+  Connection closed by foreign host.
+
+=cut
+
+use strict;
+use warnings;
+
+use Schedule::Cron;
+use Socket ':crlf';
+use IO::Socket::INET;
+
+my $port = 65331;
+our $password = 'Purfect';
+
+our( $lsock, $rin, $win, $maxfd, %servers );
+
+my $cron = new Schedule::Cron( sub { print 'Loaded entry: ', join('', @_ ), "\n"; }, {
+                                        nofork => 1,
+                                        loglevel => 0,
+                                        log => sub { print $_[1], "\n"; },
+                                        sleep => \&idler
+                                       } );
+
+$cron->add_entry( "* * * * *", \&init, 'Init', $cron );
+$cron->add_entry( "0 0 1 1 *", sub { print "Happy New Year\n"; }, "NewYear" );
+
+print "Please wait while initialization is scheduled\n";
+
+$cron->run( { detach => 0 } );
+
+exit;
+
+
+sub idler {
+    my( $time ) = @_;
+
+    my( $rout, $wout );
+
+    my( $nfound, $ttg ) = select( $rout=$rin, $wout=$win, undef, $time );
+    if( $nfound ) {
+        if( $nfound == -1 ) {
+            die "select() error: $!\n"; # This will be an internal error, such as a stale fd.
+        }
+        for( my $n = 0; $n <= $maxfd; $n++ ) {
+            if( vec( $rout, $n, 1 ) ) {
+                my $s = $servers{$n};
+                $s->{rsub}->( );
+            }
+        }
+        for( my $n = 0; $n <= $maxfd; $n++ ) {
+            if( vec( $wout, $n, 1 ) ) {
+                my $s = $servers{$n};
+                $s->{wsub}->( );
+            }
+        }
+    }
+}
+
+# First task run initializes (usually in daemon, after forking closed open files)
+# I suppose this could be a postfork callback, but there isn't one...
+
+sub init {
+    my( $name, $cron ) = @_;
+
+    $cron->delete_entry( 'Init' );
+
+    $rin = '';
+    $win = '';
+
+    $lsock = IO::Socket::INET->new(
+                                   LocalAddr => "localhost:$port",
+                                   Proto => 'tcp',
+                                   Type => SOCK_STREAM,
+                                   Listen => 5,
+                                   ReuseAddr => 1,
+                                   Blocking => 0,
+                                  ),
+                                    or die "Unable to open status port $port $!\n";
+    vec( $rin, ($maxfd = $lsock->fileno()), 1 ) = 1;
+    $servers{$maxfd} = { rsub=>sub { newConn( $lsock, $cron ); } };
+
+    print "Ready, my port is localhost::$port\n";
+
+    return;
+}
+
+sub newConn {
+    my( $lsock, $cron ) = @_;
+
+    my $sock = $lsock->accept();
+
+    $sock->blocking(0);
+    my $cx = {
+              rbuf => '',
+              wbuf => 'Password: ',
+              };
+    my $fd = $sock->fileno();
+    $maxfd = $fd if( $maxfd < $fd );
+
+    vec( $rin, $fd, 1 ) = 1;
+    vec( $win, $fd, 1 ) = 1;
+    $servers{$fd} = { rsub=>sub { serverRd( $sock, $cx, $fd ); },
+                      wsub=>sub { serverWr( $sock, $cx, $fd ); },
+                      cron=>$cron,
+                    };
+}
+
+sub serverRd {
+    my( $sock, $cx, $fd ) = @_;
+
+    # Read whatever is available.  1000 is arbitrary, 1 will work (with lots of overhead).
+    # Huge will prevent any other thread from running.
+
+    my $rn= $sock->sysread( $cx ->{rbuf}, 1000, length $cx->{rbuf} );
+    unless( defined $rn ) {
+        print "Read error: $!\n";
+    }
+    unless( $rn ) { # Connection closed by client
+        vec( $rin, $fd, 1 ) = 0;
+        vec( $win, $fd, 1 ) = 0;
+        $sock->close();
+        undef $cx;
+        return;
+    }
+
+    # Assemble reads to form whole lines
+    # Decode each line as a command.
+
+    while( $cx->{rbuf} =~ /$LF/sm ) {
+        $cx->{rbuf} =~ s/$CR//g;
+        my( $line, $rest );
+        ($line, $rest) = split( /$LF/, $cx->{rbuf}, 2 );
+        $rest = '' unless( defined $rest );
+        $cx->{rbuf} = $rest;
+
+        # This is not secure, but one has to do something.
+        # Demos always get used for more than they should..
+        # Please do better...like user/account validation
+        # using the system services.
+
+        unless( $cx->{authenticated} ){
+            if( $line eq $password ) {
+                $cx->{authenticated} = 1;
+                $cx->{wbuf} .= "Password accepted$CR$LF";
+            } else {
+                $cx->{wbuf} .= "Password refused.$CR${LF}Password: ";
+            }
+            next;
+        }
+
+        if( $line =~ /^STATUS$/i ) {
+            $cx->{wbuf} .= status( $cron );
+        } elsif( $line =~ /^ADD\s+(\w+)\s+"(.*?)"\s+(.*)$/i ) {
+            $cron->add_entry( $2, \&announce, $1, $3 );
+            $cx->{wbuf} .= "Added $2$CR$LF";
+        } elsif( $line =~ /^DEL(?:ETE)?\s+(\w+)$/i ) {
+            my $name = $1;
+            my $idx = $cron->check_entry( $name );
+            if( defined $idx ) {
+                $cron->delete_entry( $idx );
+                $cx->{wbuf} .= "Deleted $name$CR$LF";
+            } else {
+                $cx->{wbuf} .= "$name not found$CR$LF";
+            }
+        } elsif( $line =~ /^LOAD\s(.*)$/i ) {
+            my $cfg = $1; # Danger: File permissions of server are used here.
+              eval {
+                  $cron->load_crontab( $cfg );
+              };
+            my $emsg = $@;
+            $emsg =~ s/\n/$CR$LF/gms;
+            $cx->{wbuf} .= $emsg || "Loaded $cfg$CR$LF";
+        } elsif( $line =~ /^Q(?:uit)?$/i ) {
+            $cx->{wbuf} .= "Bye$CR$LF";
+            $cx->{wend} = 1;
+        } else {
+            $cx->{wbuf} .= "Unrecognized command: $line$CR$LF";
+        }
+    }
+    serverWr( $sock, $cx, $fd );
+}
+
+# Server write process
+#
+# Output as much as possible from our buffer.
+# If more remains, keep select mask active
+# If done, clear select mask.  If last write, close socket.
+
+sub serverWr {
+    my( $sock, $cx, $fd ) = @_;
+
+    if( length $cx->{wbuf} ) {
+        my $written = $sock->syswrite( $cx->{wbuf} );
+
+        $cx->{wbuf} = substr( $cx->{wbuf}, $written );
+    }
+    if( length $cx->{wbuf} ) {
+        vec( $win, $fd, 1 ) = 1;
+        return;
+    } else {
+        vec( $win, $fd, 1 ) = 0;
+        if( $cx->{wend} ) {
+            vec( $rin, $fd, 1 ) = 0;
+            $sock->close();
+            return;
+        }
+    }
+}
+
+sub announce {
+    my( $id, $msg ) = @_;
+
+    print "$id: $msg\n";
+    return;
+}
+
+sub status {
+    my $cron = shift;
+
+    my $maxtwid = 0;
+    my @entries = map { $_->[0] } sort { $a->[1] <=> $b->[1] }
+                                           map { 
+                                                 my $time = $_->{time};
+                                                 $maxtwid = length $time if( $maxtwid < length $time );
+                                                 [ $_, 
+                                                   $cron->get_next_execution_time( $time ),
+                                                 ]
+                                               } $cron->list_entries();
+    my $msg = '';
+    foreach my $qe ( @entries ) {
+        my $job = $cron->check_entry( $qe->{args}->[0] );
+        next unless( defined $job ); #??
+        $msg .= sprintf( "Job %-4s %-*s Next: %s - %s", 
+                         $job, $maxtwid, $qe->{time},
+                         (scalar localtime( $cron->get_next_execution_time( $qe->{time}, 0 ) )),
+                         $qe->{args}->[0] ||  '<Unnamed>', # Task name
+                       );
+        if( 1 ) {
+            $msg .= '( ';
+            my @uargs = @{$qe->{args}};
+            $msg .= join( ', ', @uargs[1..$#uargs] ) . ' )';
+        }
+        $msg .= "\n";
+    }
+    $msg .= "End of job queue\n";
+
+    return $msg;
+}
-- 
cgit v1.2.3


From 3beb0572df876262ebce9e6b940fc7908d2cbfd3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 3 Jun 2011 10:11:24 +0200
Subject: Tuned deps, release 1.01_3

---
 Build.PL             | 2 +-
 MANIFEST             | 2 ++
 META.yml             | 6 +++---
 Makefile.PL          | 7 ++++++-
 lib/Schedule/Cron.pm | 2 +-
 5 files changed, 13 insertions(+), 6 deletions(-)

diff --git a/Build.PL b/Build.PL
index 063a514..77b6758 100644
--- a/Build.PL
+++ b/Build.PL
@@ -11,7 +11,7 @@ my $build = Module::Build->new
    license => "perl",
    
    requires => {
-                "Time::ParseDate" => "99.00",
+                "Time::ParseDate" => "2011.0505",
                 "Data::Dumper" => "0"
                },
    
diff --git a/MANIFEST b/MANIFEST
index 5a7211f..6f1e3fc 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -2,6 +2,8 @@ Build.PL
 ChangeLog
 CHANGES
 examples/simple.pl
+examples/cron.tab
+examples/custom_sleep.pl
 lib/Schedule/Cron.pm
 Makefile.PL
 MANIFEST			This list of files
diff --git a/META.yml b/META.yml
index 91d6828..7d3078a 100644
--- a/META.yml
+++ b/META.yml
@@ -17,10 +17,10 @@ name: Schedule-Cron
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.01_2
+    version: 1.01_3
 requires:
   Data::Dumper: 0
-  Time::ParseDate: 99.00
+  Time::ParseDate: 2011.0505
 resources:
   license: http://dev.perl.org/licenses/
-version: 1.01_2
+version: 1.01_3
diff --git a/Makefile.PL b/Makefile.PL
index 0af5e60..e99b1dd 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -7,10 +7,15 @@ WriteMakefile
    ($] >= 5.005
     ? (ABSTRACT   => 'Cron-like scheduler for Perl subroutines',
        AUTHOR     => 'Roland Huss (roland@cpan.org)',
+       META_MERGE  => {
+                       resources  => {
+                                      repository => 'https://github.com/rhuss/schedule-cron',
+                                     },
+                      },
        PL_FILES => {})
     : ()),
    ($ExtUtils::MakeMaker::VERSION >= 6.3002 ?
     ('LICENSE'		=> 'perl', ) : ()),
-   PREREQ_PM => { "Time::ParseDate" => '99.00',"Data::Dumper" => 0},
+   PREREQ_PM => { "Time::ParseDate" => '2011.0505',"Data::Dumper" => 0},
    'dist' => {COMPRESS=>'gzip',SUFFIX=>'gz'}
   );
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 0e62d94..49364c1 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.01_2";
+$VERSION = "1.01_3";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From b5e88cfef540a5b4eefe8496d1e3e7fe5d0aae83 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Mon, 6 Jun 2011 07:50:30 +0200
Subject: SKip plan only if requires() fails alone

---
 t/kwalitee.t | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/t/kwalitee.t b/t/kwalitee.t
index 7c25a3b..8f1df5f 100644
--- a/t/kwalitee.t
+++ b/t/kwalitee.t
@@ -1,6 +1,12 @@
 #!/usr/bin/perl
 use Test::More;
 
-eval { require Test::Kwalitee; Test::Kwalitee->import() };
+eval { 
+  require Test::Kwalitee; 
+};
 
-plan( skip_all => 'Test::Kwalitee not installed; skipping' ) if $@;
+if ($@) {
+    plan( skip_all => 'Test::Kwalitee not installed; skipping' ); 
+} else {
+    Test::Kwalitee->import();
+}
-- 
cgit v1.2.3


From a65214a7eccc6804c3dc95e6d9b3a837f52a1433 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Mon, 6 Jun 2011 07:51:06 +0200
Subject: Preparation for 1.01

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 49364c1..4169343 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.01_3";
+$VERSION = "1.01";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 578de992848db35dc41018f3abccd318e5deecad Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Mon, 6 Jun 2011 08:00:53 +0200
Subject: Updated.

---
 examples/custom_sleep.pl | 66 ++++++++++++++++++++++++++++++++++++++++--------
 1 file changed, 56 insertions(+), 10 deletions(-)

diff --git a/examples/custom_sleep.pl b/examples/custom_sleep.pl
index cfc143a..3d3f9e3 100644
--- a/examples/custom_sleep.pl
+++ b/examples/custom_sleep.pl
@@ -116,10 +116,11 @@ my $cron = new Schedule::Cron( sub { print 'Loaded entry: ', join('', @_ ), "\n"
                                         sleep => \&idler
                                        } );
 
-$cron->add_entry( "* * * * *", \&init, 'Init', $cron );
+$cron->add_entry( "* * * * * *", \&init, 'Init', $cron );
 $cron->add_entry( "0 0 1 1 *", sub { print "Happy New Year\n"; }, "NewYear" );
 
 print "Please wait while initialization is scheduled\n";
+print help();
 
 $cron->run( { detach => 0 } );
 
@@ -174,7 +175,7 @@ sub init {
     vec( $rin, ($maxfd = $lsock->fileno()), 1 ) = 1;
     $servers{$maxfd} = { rsub=>sub { newConn( $lsock, $cron ); } };
 
-    print "Ready, my port is localhost::$port\n";
+    print "Ready, my port is localhost:$port\nTo connect:\n    telnet localhost $port\n";
 
     return;
 }
@@ -243,12 +244,13 @@ sub serverRd {
             next;
         }
 
-        if( $line =~ /^STATUS$/i ) {
-            $cx->{wbuf} .= status( $cron );
+        if( $line =~ /^STAT(?:US)?(?: (\w+))?$/i ) {
+            $cx->{wbuf} .= status( $cron, ($1 || 'normal') );
         } elsif( $line =~ /^ADD\s+(\w+)\s+"(.*?)"\s+(.*)$/i ) {
-            $cron->add_entry( $2, \&announce, $1, $3 );
-            $cx->{wbuf} .= "Added $2$CR$LF";
-        } elsif( $line =~ /^DEL(?:ETE)?\s+(\w+)$/i ) {
+            my( $name, $sched ) = ($1, $2);
+            $cron->add_entry( $sched, \&announce, $1, $3 );
+            $cx->{wbuf} .= "Added $name '$sched'$CR$LF";
+        } elsif( $line =~ /^DEL(?:ETE)?\s+(["\w]+)$/i ) {
             my $name = $1;
             my $idx = $cron->check_entry( $name );
             if( defined $idx ) {
@@ -257,7 +259,9 @@ sub serverRd {
             } else {
                 $cx->{wbuf} .= "$name not found$CR$LF";
             }
-        } elsif( $line =~ /^LOAD\s(.*)$/i ) {
+        } elsif( $line =~ /^HELP$/i ) {
+            $cx->{wbuf} .= help();
+        } elsif( $line =~ /^LOAD\s([\w\._-]+)$/i ) {
             my $cfg = $1; # Danger: File permissions of server are used here.
               eval {
                   $cron->load_crontab( $cfg );
@@ -311,6 +315,7 @@ sub announce {
 
 sub status {
     my $cron = shift;
+    my $level = shift;
 
     my $maxtwid = 0;
     my @entries = map { $_->[0] } sort { $a->[1] <=> $b->[1] }
@@ -321,7 +326,7 @@ sub status {
                                                    $cron->get_next_execution_time( $time ),
                                                  ]
                                                } $cron->list_entries();
-    my $msg = '';
+    my $msg = "Job queue\n";
     foreach my $qe ( @entries ) {
         my $job = $cron->check_entry( $qe->{args}->[0] );
         next unless( defined $job ); #??
@@ -330,7 +335,7 @@ sub status {
                          (scalar localtime( $cron->get_next_execution_time( $qe->{time}, 0 ) )),
                          $qe->{args}->[0] ||  '<Unnamed>', # Task name
                        );
-        if( 1 ) {
+        if( $level =~ /^debug$/i ) {
             $msg .= '( ';
             my @uargs = @{$qe->{args}};
             $msg .= join( ', ', @uargs[1..$#uargs] ) . ' )';
@@ -338,6 +343,47 @@ sub status {
         $msg .= "\n";
     }
     $msg .= "End of job queue\n";
+    $msg =~ s/\n/$CR$LF/mgs;
 
     return $msg;
 }
+
+use Cwd 'getcwd';
+sub help {
+    my $wd = getcwd();
+   my $msg = <<"HELP";
+CAUTION: Not production code.  NOT secure.
+Do NOT run from privileged account.
+
+Commands:
+    status
+       Shows queue
+
+    status debug
+       With argument lists
+
+    add name "schedule" A string to be printed when executed
+       Adds a new task on specified schedule
+
+    delete name
+       Deletes a task (by name)
+
+    help
+      This message.
+
+    load file
+        Loads a crontab file from $wd
+        CAUTION, this is with server permissions.  If 
+        the server can read /etc/passwd (or anything else), 
+        it will display it in the error messages.  
+        As I said, NOT production...
+
+    quit
+        Exits.
+
+HELP
+
+   $msg =~ s/\n/$CRLF/gms;
+
+   return $msg;
+}
-- 
cgit v1.2.3


From ab8c30db6af27a7409e0c7f71654f26624239ffe Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Mon, 6 Jun 2011 12:12:16 +0200
Subject: Update for 1.01

---
 META.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/META.yml b/META.yml
index 7d3078a..2adb717 100644
--- a/META.yml
+++ b/META.yml
@@ -17,10 +17,10 @@ name: Schedule-Cron
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.01_3
+    version: 1.01
 requires:
   Data::Dumper: 0
   Time::ParseDate: 2011.0505
 resources:
   license: http://dev.perl.org/licenses/
-version: 1.01_3
+version: 1.01
-- 
cgit v1.2.3


From 3ec8c35743406f4997dc3e5e88aca436c04a5121 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 11:51:25 +0100
Subject: Fixed typos in documentation (#88521)

---
 CHANGES              |  1 +
 lib/Schedule/Cron.pm | 28 ++++++++++++++--------------
 2 files changed, 15 insertions(+), 14 deletions(-)

diff --git a/CHANGES b/CHANGES
index 00621f5..45afcf5 100644
--- a/CHANGES
+++ b/CHANGES
@@ -13,6 +13,7 @@
   * loglevel: Tuning of logoutput
   * nostatus: Avoid setting $0 to next schedule time
   * sleep: Custom sleep() function between two calls
+- Fixed typos in the documentation (#88521)
   
 1.00
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 4169343..0b2dc88 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -123,7 +123,7 @@ my @LOWMAP = (
              );
 
 
-# Currently, there are two ways for reaping. One, which only waits explicitely
+# Currently, there are two ways for reaping. One, which only waits explicitly
 # on PIDs it forked on its own, and one which waits on all PIDs (even on those
 # it doesn't forked itself). The later has been proved to work on Win32 with
 # the 64 threads limit (RT #56926), but not when one creates forks on ones
@@ -175,7 +175,7 @@ sub _reaper_all {
         if ($kid != 0 && $kid != -1 && defined $STARTEDCHILD{$kid}) 
         {
             # We don't delete the hash entry here to avoid an issue
-            # when modifyinga global hash from multiple threads
+            # when modifying global hash from multiple threads
             $STARTEDCHILD{$kid} = 0;
             dbg "Reaped child $kid" if $DEBUG;
         }
@@ -543,11 +543,11 @@ Examples:
 In addition, ranges or lists of names are allowed. 
 
 An optional sixth column can be used to specify the seconds within the
-minute. If not present, it is implicitely set to "0".
+minute. If not present, it is implicitly set to "0".
 
 B<Command specification>
 
-The subroutine to be executed when the the C<$timespec> matches can be
+The subroutine to be executed when the C<$timespec> matches can be
 specified in several ways.
 
 First, if the optional C<arguments> are lacking, the default dispatching
@@ -680,10 +680,10 @@ The order index of each entry can be used within C<update_entry>, C<get_entry>
 and C<delete_entry>. But be aware, when you are deleting an entry, that you
 have to refetch the list, since the order will have changed.
 
-Note that these entries are returned by value and were opbtained from the
+Note that these entries are returned by value and were obtained from the
 internal list by a deep copy. I.e. you are free to modify it, but this won't
 influence the original entries. Instead use C<update_entry> if you need to
-modify an exisiting crontab entry.
+modify an existing crontab entry.
 
 =cut
 
@@ -761,7 +761,7 @@ sub delete_entry
 
 =item $cron->update_entry($idx,$entry)
 
-Updates the entry with index C<$idx>. C<$entry> is a hash ref as descibed in
+Updates the entry with index C<$idx>. C<$entry> is a hash ref as described in
 C<list_entries()> and must contain at least a value C<$entry-E<gt>{time}>. If no
 C<$entry-E<gt>{dispatcher}> is given, then the default dispatcher is used.  This
 method returns the old entry on success, C<undef> otherwise.
@@ -874,7 +874,7 @@ sub run
             unless (@{$self->{queue}}) # Queue length
             { 
                 # Last job deleted itself, or we were run with no entries.
-                # We can't return, so throw an exception - perhaps somone will catch.
+                # We can't return, so throw an exception - perhaps someone will catch.
                 die "No more jobs to run\n";
             }
             my ($index,$time) = @{shift @{$self->{queue}}};
@@ -1305,7 +1305,7 @@ sub _update_queue
 
 
 # The heart of the module.
-# calulate the next concrete date
+# calculate the next concrete date
 # for execution from a crontab entry
 sub _calc_time 
 { 
@@ -1529,7 +1529,7 @@ sub _calc_time
         }
     }
 
-    # Die with an error because we couldnt find a next execution entry
+    # Die with an error because we couldn't find a next execution entry
     my $dumper = new Data::Dumper($expanded);
     $dumper->Terse(1);
     $dumper->Indent(0);
@@ -1798,7 +1798,7 @@ sub _verify_expanded_cron_entry {
 =head1 DST ISSUES
 
 Daylight saving occurs typically twice a year: In the first switch, one hour is
-skipped. Any job which which triggers in this skipped hour will be fired in the
+skipped. Any job which triggers in this skipped hour will be fired in the
 next hour. So, when the DST switch goes from 2:00 to 3:00 a job which is
 scheduled for 2:43 will be executed at 3:43.
 
@@ -1811,11 +1811,11 @@ would execute a second time. The reason is the way how L<Time::ParseDate>
 calculates epoch times for dates given like C<02:50:00 2009/10/25>. Should it
 return the seconds since 1970 for this time happening 'first', or for this time
 in the extra hour ? As it turns out, L<Time::ParseDate> returns the epoch time
-of the first occurence for C<PST8PDT> and for C<MET> it returns the second
-occurence. Unfortunately, there is no way to specify I<which> entry
+of the first occurrence for C<PST8PDT> and for C<MET> it returns the second
+occurrence. Unfortunately, there is no way to specify I<which> entry
 L<Time::ParseDate> should pick (until now). Of course, after all, this is
 obviously not L<Time::ParseDate>'s fault, since a simple date specification
-within the DST backswitch period B<is> ambigious. However, it would be nice if
+within the DST backswitch period B<is> ambiguous. However, it would be nice if
 the parsing behaviour of L<Time::ParseDate> would be consistent across time
 zones (a ticket has be raised for fixing this). Then L<Schedule::Cron>'s
 behaviour within a DST backward switch would be consistent as well.
-- 
cgit v1.2.3


From 58b132bf41aeda7ed265743a7298f931d49721b6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 12:07:37 +0100
Subject: Increased version number.

---
 CHANGES              | 4 +++-
 lib/Schedule/Cron.pm | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/CHANGES b/CHANGES
index 45afcf5..b4bb86c 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,6 @@
+
+- Fixed typos in the documentation (#88521)
+
 1.01
 
 - Fix for RT #56926 which causes systems without SIGCHLD to exit on
@@ -13,7 +16,6 @@
   * loglevel: Tuning of logoutput
   * nostatus: Avoid setting $0 to next schedule time
   * sleep: Custom sleep() function between two calls
-- Fixed typos in the documentation (#88521)
   
 1.00
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 0b2dc88..7ec47fd 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.01";
+$VERSION = "1.02_1";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 4166a2b84bdbe84b4927f87efcbd014ccc996484 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 12:20:41 +0100
Subject: Fixed debug output.

---
 CHANGES              | 2 ++
 lib/Schedule/Cron.pm | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/CHANGES b/CHANGES
index b4bb86c..38b91b7 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,5 +1,7 @@
+1.02_1
 
 - Fixed typos in the documentation (#88521)
+- Fixed debug output slipped id (#83462)
 
 1.01
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 7ec47fd..24d2b90 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -171,7 +171,7 @@ sub _reaper_all {
         # if there are no finished child processes. Simple 'wait'
         # waits blocking on childs.
         $kid = $HAS_POSIX ? waitpid(-1, WNOHANG) : wait;
-        print "Kid: $kid\n";
+        dbg "Kid: $kid" if $DEBUG;
         if ($kid != 0 && $kid != -1 && defined $STARTEDCHILD{$kid}) 
         {
             # We don't delete the hash entry here to avoid an issue
-- 
cgit v1.2.3


From 68ff72558371e4e02d9e04e70690a593d2fb15ac Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 11:32:11 +0000
Subject: Fixed error for empty lines in crontabs (#75176)

---
 CHANGES              | 1 +
 lib/Schedule/Cron.pm | 3 +--
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/CHANGES b/CHANGES
index 38b91b7..11b82aa 100644
--- a/CHANGES
+++ b/CHANGES
@@ -2,6 +2,7 @@
 
 - Fixed typos in the documentation (#88521)
 - Fixed debug output slipped id (#83462)
+- Fixed crontab with empty lines (#75176)
 
 1.01
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 24d2b90..9c97039 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -442,8 +442,7 @@ sub load_crontab
       # Strip off trailing comments and ignore empty 
       # or pure comments lines:
       s/#.*$//;
-      next if /^$/;
-      next if /^$/;
+      next if /^\s*$/;
       next if /^\s*#/;
       chomp;
       s/\s*(.*)\s*$/$1/;
-- 
cgit v1.2.3


From fc15e06ccd06d1ecd86e82321ae6dde23384a972 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 12:54:51 +0000
Subject: Fixed skipping of jobs triggered at the same time when rescheduling
 (#70975)

---
 CHANGES                       |  1 +
 lib/Schedule/Cron.pm          | 35 +++++++++++++++++++------
 t/same_time_with_reschedule.t | 60 +++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 88 insertions(+), 8 deletions(-)
 create mode 100644 t/same_time_with_reschedule.t

diff --git a/CHANGES b/CHANGES
index 11b82aa..c828b5f 100644
--- a/CHANGES
+++ b/CHANGES
@@ -3,6 +3,7 @@
 - Fixed typos in the documentation (#88521)
 - Fixed debug output slipped id (#83462)
 - Fixed crontab with empty lines (#75176)
+- Fixed skipping of jobs triggered at the same time when rescheduling (#70975)
 
 1.01
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 9c97039..b9d0eac 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -876,16 +876,18 @@ sub run
                 # We can't return, so throw an exception - perhaps someone will catch.
                 die "No more jobs to run\n";
             }
-            my ($index,$time) = @{shift @{$self->{queue}}};
+            my ($indexes,$time) = $self->_get_next_jobs();
             my $now = time;
             my $sleep = 0;
             if ($time < $now)
             {
                 if ($cfg->{skip})
                 {
-                    $log->(0,"Schedule::Cron - Skipping job $index")
-                      if $log && $loglevel <= 0;
-                    $self->_update_queue($index);
+                    for my $index (@$indexes) {
+                        $log->(0,"Schedule::Cron - Skipping job $index")
+                          if $log && $loglevel <= 0;
+                        $self->_update_queue($index);
+                    }
                     next;
                 }
                 # At least a safety airbag
@@ -919,7 +921,9 @@ sub run
                 $sleep = $time - time;
             }
 
-            $self->_execute($index,$cfg);
+            for my $index (@$indexes) {
+                $self->_execute($index,$cfg);
+            }
             $self->_cleanup_process_list($cfg);
 
             if ($self->{entries_changed}) {
@@ -927,7 +931,9 @@ sub run
                $self->_rebuild_queue;
                delete $self->{entries_changed};
             } else {
-               $self->_update_queue($index);
+                for my $index (@$indexes) {
+                    $self->_update_queue($index);
+                }
             }
         } 
     };
@@ -1171,7 +1177,7 @@ sub _rebuild_queue
 { 
     my $self = shift;
     $self->{queue} = [ ];
-    #  dbg "TT: ",$#{$self->{time_table}};
+    #dbg "TT: ",$#{$self->{time_table}};
     for my $id (0..$#{$self->{time_table}}) 
     {
         $self->_update_queue($id);
@@ -1189,6 +1195,19 @@ sub _deep_copy_entry
     return $copied_entry;
 }
 
+# Return an array with an arrayref of entry index and the time which should be
+# executed now
+sub _get_next_jobs {
+    my $self = shift;
+    my ($index,$time) = @{shift @{$self->{queue}}};
+    my $indexes = [ $index ];
+    while (@{$self->{queue}} && $self->{queue}->[0]->[1] == $time) {
+        my $index = @{shift @{$self->{queue}}}[0];
+        push @$indexes,$index;
+    }
+    return $indexes,$time;
+}
+
 # Execute a subroutine whose time has come
 sub _execute 
 { 
@@ -1299,7 +1318,7 @@ sub _update_queue
 
     dbg "Updating Queue: ",scalar(localtime($new_time)) if $DEBUG;
     $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
-    #  dbg "Queue now: ",Dumper($self->{queue});
+    dbg "Queue now: ",Dumper($self->{queue});
 }
 
 
diff --git a/t/same_time_with_reschedule.t b/t/same_time_with_reschedule.t
new file mode 100644
index 0000000..65123b7
--- /dev/null
+++ b/t/same_time_with_reschedule.t
@@ -0,0 +1,60 @@
+#!/usr/bin/perl
+
+use Test::More tests => 6;
+use Schedule::Cron;
+use strict;
+#!/usr/bin/perl
+
+use Schedule::Cron;
+use Data::Dumper;
+
+my $CALLED = {};
+
+# Create new object with default dispatcher
+my $scheduler = Schedule::Cron->new( sub { 
+                                         warn "unknown action"; 
+                                     });
+
+my $other = sub { $CALLED->{OTHER}++ };
+
+my $sec = (localtime)[0];
+
+my $e = entry(2,3,4);
+
+my $tasknum = 0;
+my $do = sub {  
+    $CALLED->{DO}++;
+    if ($tasknum < 2) {
+#        print "adding something\n";
+        my $string = "task" . $tasknum ."\n";
+        $scheduler->add_entry($e, { subroutine => &task($tasknum + 1)}); 
+        $tasknum++; 
+    } 
+};
+	
+
+sub task {
+    my $num = shift;
+    return sub {
+        $CALLED->{"T" . $num}++;
+    };
+}
+#print $e,"\n";;
+$scheduler->add_entry($e, { subroutine => $do });
+$scheduler->add_entry($e, { subroutine => $other });
+$scheduler->add_entry(entry(5), { subroutine => sub { die "E1\n" }});
+
+eval {
+    $scheduler->run({ nofork => 1 });
+};
+is($@,"E1\n","Finished by last action");
+ok($CALLED->{DO} > 0,'$do called ' . $CALLED->{DO});
+ok($CALLED->{OTHER} > 0,'$other called ' . $CALLED->{OTHER});
+ok($CALLED->{T1} > 0,"T1 called");
+ok($CALLED->{T2} > 0,"T2 called");
+is($CALLED->{DO},$CALLED->{OTHER}, '$do and $other are the same');
+#print Dumper($CALLED);
+
+sub entry {
+    return "* * * * * " . join (",",map { ($sec + $_) % 60 } @_);
+}
-- 
cgit v1.2.3


From c18285e9feead4b349c6b4ea32821a8443e88b76 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 14:00:00 +0000
Subject: Added new option 'timeshift' (#69177) and updated meta data and
 readme.

---
 CHANGES              |  1 +
 MANIFEST             |  2 ++
 META.yml             |  6 ++++--
 README               | 17 +++++++++++++----
 lib/Schedule/Cron.pm | 43 +++++++++++++++++++++++++++++++++++++++----
 5 files changed, 59 insertions(+), 10 deletions(-)

diff --git a/CHANGES b/CHANGES
index c828b5f..4f6ef38 100644
--- a/CHANGES
+++ b/CHANGES
@@ -4,6 +4,7 @@
 - Fixed debug output slipped id (#83462)
 - Fixed crontab with empty lines (#75176)
 - Fixed skipping of jobs triggered at the same time when rescheduling (#70975)
+- Added option "timeshift" in order to shift the execution point a bit (#69177)
 
 1.01
 
diff --git a/MANIFEST b/MANIFEST
index 6f1e3fc..8abaf10 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -24,4 +24,6 @@ t/sighandler.t
 t/startup.t
 t/test.crontab
 t/delete_entry.t
+t/same_time_with_reschedule.t
+t/timeshift.t
 META.json
diff --git a/META.yml b/META.yml
index 2adb717..ad142ed 100644
--- a/META.yml
+++ b/META.yml
@@ -17,10 +17,12 @@ name: Schedule-Cron
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.01
+    version: 1.02_1
 requires:
   Data::Dumper: 0
   Time::ParseDate: 2011.0505
 resources:
+  bugtracker: https://github.com/rhuss/schedule-cron/issues
   license: http://dev.perl.org/licenses/
-version: 1.01
+  repository: git://github.com/rhuss/schedule-cron.git
+version: 1.02_1
diff --git a/README b/README
index d413cdb..b861f44 100644
--- a/README
+++ b/README
@@ -91,9 +91,6 @@ starting jobs and detaching itself to the background:
   * For  detaching it  uses either  setsid (POSIX)  or the  ioctl call
     TIOCNOTTY
 
-The roadmap  include plans  for porting the  fork mechanism over  to a
-thread based scheme, which should make dynamic update much easier.
-
 If the  system calls mentioned  above are not available  (which should
 hapen nowadays only  under rare circumstances), you can  still use the
 'nofork' option to run all jobs within a single process/thread. Please
@@ -142,10 +139,22 @@ execution date  (relative to  the reference time).   The dates  can be
 specified in  a format understood by  'parsedate' from Time::ParseDate
 (like 'now  + 5  days').  Please include  the output of  this command.
 
+REPOSITORY
+----------
+
+Schedule::Cron's         source          is         located         at
+https://github.com/rhuss/schedule-cron  Please feel  free  to send  me
+pull requests if they apply  to the license below.  Also, don't forget
+documentation and tests.
+
+Please note also, that the active development for this module has been
+stopped since it is considered  to be feature complete. Bugs and minor
+(external) additions will be added from time to time, though.
+
 LICENSE
 -------
 
-Copyright 1999-2011 Roland Huss.
+Copyright 1999-2013 Roland Huss.
 
 This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b9d0eac..cce0447 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -363,9 +363,11 @@ sub new
     die "Dispatcher not a ref to a subroutine" unless ref($dispatcher) eq "CODE";
     my $cfg = ref($_[0]) eq "HASH" ? $_[0] : {  @_ };
     $cfg->{processprefix} = "Schedule::Cron" unless $cfg->{processprefix};
+    my $timeshift = $cfg->{timeshift} || 0;
     my $self = { 
                 cfg => $cfg,
                 dispatcher => $dispatcher,
+                timeshift => $timeshift,
                 queue => [ ],
                 map => { }
              };
@@ -877,7 +879,7 @@ sub run
                 die "No more jobs to run\n";
             }
             my ($indexes,$time) = $self->_get_next_jobs();
-            my $now = time;
+            my $now = $self->_now();
             my $sleep = 0;
             if ($time < $now)
             {
@@ -918,7 +920,7 @@ sub run
                 } else {
                     sleep($sleep);
                 }
-                $sleep = $time - time;
+                $sleep = $time - $self->_now();
             }
 
             for my $index (@$indexes) {
@@ -1167,6 +1169,33 @@ sub get_next_execution_time
   }
 }
 
+=item $cron->set_timeshift($ts)
+
+Modify global time shift for all timetable. The timeshift is subbed from localtime
+to calculate next execution time for all scheduled jobs.
+
+ts parameter must be in seconds. Default value is 0. Negative values are allowed to
+shift time in the past.
+
+Returns actual timeshift in seconds.
+
+Example:
+
+   $cron->set_timeshift(120);
+
+   Will delay all jobs 2 minutes in the future.
+
+=cut
+
+sub set_timeshift
+{
+    my $self = shift;
+    my $value = shift || 0;
+
+    $self->{timeshift} = $value;
+    return $self->{timeshift};
+}
+
 # ==================================================
 # PRIVATE METHODS:
 # ==================================================
@@ -1307,7 +1336,7 @@ sub _update_queue
     my $new_time = $self->get_next_execution_time($entry->{time});
     # Check, whether next execution time is *smaller* than the current time.
     # This can happen during DST backflip:
-    my $now = time;
+    my $now = $self->_now();
     if ($new_time <= $now) {
         dbg "Adjusting time calculation because of DST back flip (new_time - now = ",$new_time - $now,")" if $DEBUG;
         # We are adding hours as long as our target time is in the future
@@ -1322,6 +1351,12 @@ sub _update_queue
 }
 
 
+# Out "now" which can be shifted if as argument
+sub _now { 
+    my $self = shift;
+    return time + $self->{timeshift};
+}
+
 # The heart of the module.
 # calculate the next concrete date
 # for execution from a crontab entry
@@ -1331,7 +1366,7 @@ sub _calc_time
     my $now = shift;
     my $expanded = shift;
 
-    my $offset = ($expanded->[5] ? 1 : 60);
+    my $offset = ($expanded->[5] ? 1 : 60) + $self->{timeshift};
     my ($now_sec,$now_min,$now_hour,$now_mday,$now_mon,$now_wday,$now_year) = 
       (localtime($now+$offset))[0,1,2,3,4,6,5];
     $now_mon++; 
-- 
cgit v1.2.3


From 01cbf7fa949d25d0e7498dfe4040df651006e4d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 13 Dec 2013 14:18:38 +0000
Subject: Minor modifications

---
 lib/Schedule/Cron.pm | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index cce0447..524a47c 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -127,7 +127,7 @@ my @LOWMAP = (
 # on PIDs it forked on its own, and one which waits on all PIDs (even on those
 # it doesn't forked itself). The later has been proved to work on Win32 with
 # the 64 threads limit (RT #56926), but not when one creates forks on ones
-# one. The specific reaper works for RT #55741.
+# own. The specific reaper works for RT #55741.
 
 # It tend to use the specific one, if it also resolves RT #56926. Both are left
 # here for reference until a decision has been done for 1.01
@@ -1347,7 +1347,7 @@ sub _update_queue
 
     dbg "Updating Queue: ",scalar(localtime($new_time)) if $DEBUG;
     $self->{queue} = [ sort { $a->[1] <=> $b->[1] } @{$self->{queue}},[$index,$new_time] ];
-    dbg "Queue now: ",Dumper($self->{queue});
+    #dbg "Queue now: ",Dumper($self->{queue});
 }
 
 
-- 
cgit v1.2.3


From 33bb3cf81aedb34f677c920d8e085c8faf3755ef Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Thu, 19 Dec 2013 08:59:25 +0100
Subject: Fixed tests.

---
 CHANGES              |  3 ++-
 lib/Schedule/Cron.pm | 23 +++++++++++++++++++----
 t/sighandler.t       |  6 +++---
 3 files changed, 24 insertions(+), 8 deletions(-)

diff --git a/CHANGES b/CHANGES
index 4f6ef38..ac116dd 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,10 +1,11 @@
-1.02_1
+1.02_2
 
 - Fixed typos in the documentation (#88521)
 - Fixed debug output slipped id (#83462)
 - Fixed crontab with empty lines (#75176)
 - Fixed skipping of jobs triggered at the same time when rescheduling (#70975)
 - Added option "timeshift" in order to shift the execution point a bit (#69177)
+- Made $? local in the reaper sub (#69110 and #69116)
 
 1.01
 
diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 524a47c..a8ea7ae 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.02_1";
+$VERSION = "1.02_2";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
@@ -138,7 +138,7 @@ sub REAPER {
 
 # Specific reaper
 sub _reaper_specific {
-    local ($!,%!);
+    local ($!,%!,$?);
     if ($HAS_POSIX)
     {
         foreach my $pid (keys %STARTEDCHILD) {
@@ -163,7 +163,13 @@ sub _reaper_specific {
 
 # Catch all reaper
 sub _reaper_all {
-    local ($!,%!);
+    #local ($!,%!,$?,${^CHILD_ERROR_NATIVE});
+
+    # Localizing ${^CHILD_ERROR_NATIVE} breaks signalhander.t which checks that
+    # chained SIGCHLD handlers are called. I don't know why, though, hence I
+    # leave it out for now. See #69916 for some discussion why this handler
+    # might be needed.
+    local ($!,%!,$?);
     my $kid;
     do 
     {
@@ -860,9 +866,14 @@ sub run
     unless ($cfg->{nofork}) {
         my $old_child_handler = $SIG{'CHLD'};
         $SIG{'CHLD'} = sub {
+            dbg "Calling reaper" if $DEBUG;
             &REAPER();
             if ($old_child_handler && ref $old_child_handler eq 'CODE')
             {
+                dbg "Calling old child handler" if $DEBUG;
+                #use B::Deparse ();
+                #my $deparse = B::Deparse->new;
+                #print 'sub ', $deparse->coderef2text($old_child_handler), "\n";
                 &$old_child_handler();
             }
         };
@@ -879,6 +890,7 @@ sub run
                 die "No more jobs to run\n";
             }
             my ($indexes,$time) = $self->_get_next_jobs();
+            dbg "Jobs for $time : ",join(",",@$indexes) if $DEBUG;
             my $now = $self->_now();
             my $sleep = 0;
             if ($time < $now)
@@ -923,8 +935,11 @@ sub run
                 $sleep = $time - $self->_now();
             }
 
-            for my $index (@$indexes) {
+            for my $index (@$indexes) {                
                 $self->_execute($index,$cfg);
+                # If "skip" is set and the job takes longer than a second, then
+                # the remaining jobs are skipped.
+                last if $cfg->{skip} && $time < $self->_now();
             }
             $self->_cleanup_process_list($cfg);
 
diff --git a/t/sighandler.t b/t/sighandler.t
index 121e658..f3427a5 100644
--- a/t/sighandler.t
+++ b/t/sighandler.t
@@ -18,13 +18,13 @@ SKIP: {
     skip "alarm() not available", 1 if $@;
     
     # Check, whether an already installed signalhandler is called
-    $SIG{CHLD} = sub { 
-        pass;
+    $SIG{CHLD} = sub {         
+        pass "SIGCHLD received";
         exit 0;
     };
     
     $SIG{ALRM} = sub { 
-        fail;
+        fail "SIGALRM received";
         exit 0;
     };
     
-- 
cgit v1.2.3


From e3e3770f696ce3b98f3b4ba44057910cb09ef38b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 20 Dec 2013 09:26:56 +0100
Subject: Added missing test file

---
 t/timeshift.t | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)
 create mode 100644 t/timeshift.t

diff --git a/t/timeshift.t b/t/timeshift.t
new file mode 100644
index 0000000..abad263
--- /dev/null
+++ b/t/timeshift.t
@@ -0,0 +1,17 @@
+#!/usr/bin/perl
+
+use Test::More tests => 1;
+use Schedule::Cron;
+use strict;
+
+my $count = 0;
+my $second = (localtime)[0];
+my $cron = new Schedule::Cron(sub {},{nofork => 1,timeshift => 10});
+
+$cron->add_entry("* * * * * " . ($second + 12) % 60,{subroutine => sub { die } });
+my $now = time;
+eval {
+    $cron->run();
+};
+my $delta = time - $now;
+ok($delta <= 3,"Call was shifted by " . $delta . " seconds (<= 3)");
-- 
cgit v1.2.3


From 55c15c7d175450ba4cd3710d031b318a91b193d5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 20 Dec 2013 09:32:58 +0100
Subject: Added missing file

---
 META.json | 48 ++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 48 insertions(+)
 create mode 100644 META.json

diff --git a/META.json b/META.json
new file mode 100644
index 0000000..91aa4ef
--- /dev/null
+++ b/META.json
@@ -0,0 +1,48 @@
+{
+   "abstract" : "cron-like scheduler for Perl subroutines",
+   "author" : [
+      "Roland Huss (roland@cpan.org)"
+   ],
+   "dynamic_config" : 1,
+   "generated_by" : "Module::Build version 0.38, CPAN::Meta::Converter version 2.110580",
+   "license" : [
+      "perl_5"
+   ],
+   "meta-spec" : {
+      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
+      "version" : "2"
+   },
+   "name" : "Schedule-Cron",
+   "prereqs" : {
+      "build" : {
+         "requires" : {
+            "Test" : 0,
+            "Test::More" : 0
+         }
+      },
+      "configure" : {
+         "requires" : {
+            "Module::Build" : 0
+         }
+      },
+      "runtime" : {
+         "requires" : {
+            "Data::Dumper" : 0,
+            "Time::ParseDate" : "2011.0505"
+         }
+      }
+   },
+   "provides" : {
+      "Schedule::Cron" : {
+         "file" : "lib/Schedule/Cron.pm",
+         "version" : "1.01"
+      }
+   },
+   "release_status" : "stable",
+   "resources" : {
+      "license" : [
+         "http://dev.perl.org/licenses/"
+      ]
+   },
+   "version" : "1.01"
+}
-- 
cgit v1.2.3


From 379699ea57515237abdc8b9fcf83e928a6e7d808 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 20 Dec 2013 09:35:14 +0100
Subject: Updated files

---
 MANIFEST  |  1 -
 META.json | 48 ------------------------------------------------
 META.yml  |  4 ++--
 3 files changed, 2 insertions(+), 51 deletions(-)
 delete mode 100644 META.json

diff --git a/MANIFEST b/MANIFEST
index 8abaf10..e8c053e 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -26,4 +26,3 @@ t/test.crontab
 t/delete_entry.t
 t/same_time_with_reschedule.t
 t/timeshift.t
-META.json
diff --git a/META.json b/META.json
deleted file mode 100644
index 91aa4ef..0000000
--- a/META.json
+++ /dev/null
@@ -1,48 +0,0 @@
-{
-   "abstract" : "cron-like scheduler for Perl subroutines",
-   "author" : [
-      "Roland Huss (roland@cpan.org)"
-   ],
-   "dynamic_config" : 1,
-   "generated_by" : "Module::Build version 0.38, CPAN::Meta::Converter version 2.110580",
-   "license" : [
-      "perl_5"
-   ],
-   "meta-spec" : {
-      "url" : "http://search.cpan.org/perldoc?CPAN::Meta::Spec",
-      "version" : "2"
-   },
-   "name" : "Schedule-Cron",
-   "prereqs" : {
-      "build" : {
-         "requires" : {
-            "Test" : 0,
-            "Test::More" : 0
-         }
-      },
-      "configure" : {
-         "requires" : {
-            "Module::Build" : 0
-         }
-      },
-      "runtime" : {
-         "requires" : {
-            "Data::Dumper" : 0,
-            "Time::ParseDate" : "2011.0505"
-         }
-      }
-   },
-   "provides" : {
-      "Schedule::Cron" : {
-         "file" : "lib/Schedule/Cron.pm",
-         "version" : "1.01"
-      }
-   },
-   "release_status" : "stable",
-   "resources" : {
-      "license" : [
-         "http://dev.perl.org/licenses/"
-      ]
-   },
-   "version" : "1.01"
-}
diff --git a/META.yml b/META.yml
index ad142ed..48bff29 100644
--- a/META.yml
+++ b/META.yml
@@ -17,7 +17,7 @@ name: Schedule-Cron
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.02_1
+    version: 1.02_3
 requires:
   Data::Dumper: 0
   Time::ParseDate: 2011.0505
@@ -25,4 +25,4 @@ resources:
   bugtracker: https://github.com/rhuss/schedule-cron/issues
   license: http://dev.perl.org/licenses/
   repository: git://github.com/rhuss/schedule-cron.git
-version: 1.02_1
+version: 1.02_3
-- 
cgit v1.2.3


From c7e5e1f2935637c671e00639accd309c63d94437 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Roland=20Hu=C3=9F?= <roland@jolokia.org>
Date: Fri, 20 Dec 2013 09:35:41 +0100
Subject: Increased version number

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index a8ea7ae..13f6ec6 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.02_2";
+$VERSION = "1.02_3";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From fcc7b54a2f46058c7f098de969c526ccd0afcd9e Mon Sep 17 00:00:00 2001
From: Alexandr Ciornii <alexchorny@gmail.com>
Date: Wed, 4 Jan 2017 15:04:42 +0200
Subject: repository for META.*

---
 Build.PL | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/Build.PL b/Build.PL
index 77b6758..e35c9e1 100644
--- a/Build.PL
+++ b/Build.PL
@@ -20,6 +20,11 @@ my $build = Module::Build->new
                       "Test" => "0",
                      },                       
    keywords => [  "Cron", "Scheduler", "Job" ],
+  meta_merge => {
+    resources => {
+      repository => 'http://github.com/rhuss/schedule-cron',
+    },
+  },
    provides => {
                 "Schedule::Cron" => {
                                file =>  "lib/Schedule/Cron.pm"
-- 
cgit v1.2.3


From fabead181f55e8b8ee5729e25d1b3c9327e95b67 Mon Sep 17 00:00:00 2001
From: Alexandr Ciornii <alexchorny@gmail.com>
Date: Wed, 4 Jan 2017 15:06:37 +0200
Subject: Fixes "Unescaped left brace in regex is illegal", RT#117437

---
 t/pretty_print_args.t | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/t/pretty_print_args.t b/t/pretty_print_args.t
index 7a1322e..e50e76b 100644
--- a/t/pretty_print_args.t
+++ b/t/pretty_print_args.t
@@ -11,4 +11,4 @@ my @args = (
            );     
 
 my $out = join(",",Schedule::Cron->_format_args(@args));
-like($out,qr/\['bla','blub',{.*?'and'\s*=>\s*'HASH\(.*?\)'.*?}\],3,{.*?'blub'\s*=>\s*'bla'.*?}/);
+like($out,qr/\['bla','blub',\{.*?'and'\s*=>\s*'HASH\(.*?\)'.*?}\],3,\{.*?'blub'\s*=>\s*'bla'.*?}/);
-- 
cgit v1.2.3


From 03a10ab00641c24ab4e25d7070b51be963acbb9a Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Sun, 4 Sep 2022 10:10:01 -0400
Subject: Add processname option for setting $0 to constant string

---
 lib/Schedule/Cron.pm | 24 ++++++++++++++++++++----
 1 file changed, 20 insertions(+), 4 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 13f6ec6..70936c9 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -334,6 +334,11 @@ option you can set it to something different. You can e.g. use C<$0> to include
 the original process name.  You can inhibit this with the C<nostatus> option, and
 prevent the argument display by setting C<loglevel> to zero or higher.
 
+=item processname => <name>
+
+Set the process name (i.e. C<$0>) to a literal string. Using this setting 
+overrides C<processprefix> and C<nostatus>.
+
 =item sleep => \&hook
 
 If specified, &hook will be called instead of sleep(), with the time to sleep
@@ -879,6 +884,10 @@ sub run
         };
     }
     
+    if (my $name = $cfg->{processname}) {
+        $0 = $name
+    }
+
     my $mainloop = sub { 
       MAIN:
         while (42)          
@@ -911,7 +920,11 @@ sub run
             {
                 $sleep = $time - $now;
             }
-            $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time)) unless $cfg->{nostatus};
+
+            unless ($cfg->{processname} || $cfg->{nostatus}) {
+                $0 = $self->_get_process_prefix()." MainLoop - next: ".scalar(localtime($time)); 
+            }
+
             if (!$time) {
                 die "Internal: No time found, self: ",$self->{queue},"\n" unless $time;
             }
@@ -1012,7 +1025,10 @@ sub run
             }
             open STDERR, '>&STDOUT' or die "Can't dup stdout: $!";
             
-            $0 = $self->_get_process_prefix()." MainLoop" unless $cfg->{nostatus};
+            unless ($cfg->{processname} || $cfg->{nostatus}) {
+                $0 = $self->_get_process_prefix()." MainLoop"; 
+            }
+
             &$mainloop();
         }
     } 
@@ -1292,10 +1308,10 @@ sub _execute
   }
 
 
-  if ($log && $loglevel <= 0 || !$cfg->{nofork} && !$cfg->{nostatus}) {
+  if ($log && $loglevel <= 0 || !$cfg->{nofork} && !$cfg->{processname} && !$cfg->{nostatus}) {
       my $args_label = (@args && $loglevel <= -1) ? " with (".join(",",$self->_format_args(@args)).")" : "";
       $0 = $self->_get_process_prefix()." Dispatched job $index$args_label"
-        unless $cfg->{nofork} || $cfg->{nostatus};
+        unless $cfg->{nofork} || $cfg->{processname} || $cfg->{nostatus};
       $log->(0,"Schedule::Cron - Starting job $index$args_label")
         if $log && $loglevel <= 0;
   }
-- 
cgit v1.2.3


From d3c30cea288b5d8aec4818695e830056d440ff30 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Thu, 8 Sep 2022 12:28:47 -0400
Subject: Add tests for processname, processprefix, and nostatus.

---
 t/process_name.t | 159 +++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 159 insertions(+)
 create mode 100644 t/process_name.t

diff --git a/t/process_name.t b/t/process_name.t
new file mode 100644
index 0000000..f2b62a7
--- /dev/null
+++ b/t/process_name.t
@@ -0,0 +1,159 @@
+#!/usr/bin/perl
+
+# Test the process naming options: processname, processprefix, and nostatus.
+
+use Test::More tests => 6;
+use Schedule::Cron;
+use strict;
+use warnings;
+
+my $orig_proc_name = $0;
+
+my $dispatch_1 = sub {
+    my $test_msg = 'process name suffixed with debug status by default';
+    my $process_name_rx = '^Schedule::Cron MainLoop - next: '.scalar(localtime).'$';
+    if ($0 =~ /$process_name_rx/) {
+        die "1-$test_msg\n";
+    }
+    else {
+        die "0-$test_msg\n";
+    }
+};
+my $cron = Schedule::Cron->new(
+    $dispatch_1,
+    nofork => 1,
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+my $error = $@;
+chomp $error;
+my ($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
+
+my $dispatch_2 = sub {
+    my $test_msg = q(process name doesn't change with nostatus);
+    if ($0 eq $orig_proc_name) {
+        die "1-$test_msg\n";
+    }
+    else {
+        die "0-$test_msg\n";
+    }
+};
+$cron = Schedule::Cron->new(
+    $dispatch_2,
+    nofork => 1,
+    nostatus => 1
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+$error = $@;
+chomp $error;
+($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
+
+my $dispatch_3 = sub {
+    my $test_msg = 'nostatus overrides processprefix';
+    if ($0 eq $orig_proc_name) {
+        die "1-$test_msg\n";
+    }
+    else {
+        print "\$0 = $0\n";
+        die "0-$test_msg\n";
+    }
+};
+$cron = Schedule::Cron->new(
+    $dispatch_3,
+    nofork => 1,
+    nostatus => 1,
+    processprefix => 'foo'
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+$error = $@;
+chomp $error;
+($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
+
+my $dispatch_4 = sub {
+    my $test_msg = 'process name prefixed with string when using processprefix';
+    my $rx = '^foo MainLoop - next: '.scalar(localtime).'$';
+    if ($0 =~ /$rx/) {
+        die "1-$test_msg\n";
+    }
+    else {
+        die "0-test_msg\n";
+    }
+};
+$cron = Schedule::Cron->new(
+    $dispatch_4,
+    nofork => 1,
+    processprefix => 'foo'
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+$error = $@;
+chomp $error;
+($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
+
+my $dispatch_5 = sub {
+    my $test_msg = 'process name set to constant string when using processname';
+    if ($0 eq 'foo') {
+        die "1-$test_msg\n";
+    }
+    else {
+        die "0-$test_msg\n";
+    }
+};
+$cron = Schedule::Cron->new(
+    $dispatch_5,
+    nofork => 1,
+    processname => 'foo'
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+$error = $@;
+chomp $error;
+($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
+
+my $dispatch_6 = sub {
+    my $test_msg = 'processname overrides nostatus and processprefix';
+    if ($0 eq 'foo') {
+        die "1-$test_msg\n";
+    }
+    else {
+        die "0-$test_msg\n";
+    }
+};
+$cron = Schedule::Cron->new(
+    $dispatch_6,
+    nofork => 1,
+    processname => 'foo',
+    nostatus => 1,
+    processprefix => 'bar'
+);
+$cron->add_entry('* * * * * 0-59');
+eval {
+    $cron->run();
+};
+$error = $@;
+chomp $error;
+($ok, $msg) = split '-', $error, 2;
+ok $ok, $msg;
+$0 = $orig_proc_name;
-- 
cgit v1.2.3


From 4787d8585c626713d3f5f935d2f16de833b80094 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Mon, 3 Oct 2022 13:27:15 -0400
Subject: Documented contributors

---
 lib/Schedule/Cron.pm | 14 ++++++++++++++
 1 file changed, 14 insertions(+)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 70936c9..1c1ba12 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1922,6 +1922,20 @@ modify it under the same terms as Perl itself.
 
 ... roland
 
+=head1 Contributors
+
+=over 4
+
+=item *
+
+Alexandr Ciornii <alexchorny@gmail.com>
+
+=item *
+
+Nicholas Hubbard <nicholashubbard@posteo.net>
+
+=back
+
 =cut
 
 1;
-- 
cgit v1.2.3


From 6285cd7a315a5e0460df82db8ef763e4e5f36adb Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Mon, 3 Oct 2022 13:28:55 -0400
Subject: Added t/process_name.t

---
 MANIFEST | 1 +
 1 file changed, 1 insertion(+)

diff --git a/MANIFEST b/MANIFEST
index e8c053e..24de02e 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -20,6 +20,7 @@ t/nofork.t
 t/pod.t
 t/pod_coverage.t
 t/pretty_print_args.t
+t/process_name.t
 t/sighandler.t
 t/startup.t
 t/test.crontab
-- 
cgit v1.2.3


From f4b63c88a1e05b208a6f387bfa88decd62c2421f Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Mon, 3 Oct 2022 13:36:52 -0400
Subject: Bumped version to "1.03"

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 1c1ba12..b2f3d64 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.02_3";
+$VERSION = "1.03";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From bb2670cfb4ef2661a54ea3e1873d5f3592ceb6a2 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Mon, 3 Oct 2022 13:48:28 -0400
Subject: Updated for version "1.03"

---
 META.yml | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/META.yml b/META.yml
index 48bff29..d2e0ab9 100644
--- a/META.yml
+++ b/META.yml
@@ -3,26 +3,26 @@ abstract: 'cron-like scheduler for Perl subroutines'
 author:
   - 'Roland Huss (roland@cpan.org)'
 build_requires:
-  Test: 0
-  Test::More: 0
+  Test: '0'
+  Test::More: '0'
 configure_requires:
-  Module::Build: 0
-dynamic_config: 1
-generated_by: 'Module::Build version 0.38, CPAN::Meta::Converter version 2.110580'
+  Module::Build: '0'
+dynamic_config: 0
+generated_by: 'Module::Build version 0.4231, CPAN::Meta::Converter version 2.150010'
 license: perl
 meta-spec:
   url: http://module-build.sourceforge.net/META-spec-v1.4.html
-  version: 1.4
+  version: '1.4'
 name: Schedule-Cron
 provides:
   Schedule::Cron:
     file: lib/Schedule/Cron.pm
-    version: 1.02_3
+    version: '1.03'
 requires:
-  Data::Dumper: 0
-  Time::ParseDate: 2011.0505
+  Data::Dumper: '0'
+  Time::ParseDate: '2011.0505'
 resources:
-  bugtracker: https://github.com/rhuss/schedule-cron/issues
   license: http://dev.perl.org/licenses/
-  repository: git://github.com/rhuss/schedule-cron.git
-version: 1.02_3
+  repository: http://github.com/rhuss/schedule-cron
+version: '1.03'
+x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
-- 
cgit v1.2.3


From 25c471007e87fee46452c5e1396466ef3b81c268 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Mon, 3 Oct 2022 14:01:02 -0400
Subject: Document changes for "1.03"

---
 CHANGES | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/CHANGES b/CHANGES
index ac116dd..69af8b4 100644
--- a/CHANGES
+++ b/CHANGES
@@ -1,3 +1,8 @@
+1.03
+
+- Added option "processname" to set $0 to constant string (#9)
+- Added tests for options "processname", "processprefix", and "nostatus" (#10)
+
 1.02_2
 
 - Fixed typos in the documentation (#88521)
-- 
cgit v1.2.3


From 777d344d5d6771c0864c550185a494badd667a35 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Thu, 6 Oct 2022 23:13:03 -0400
Subject: Updated "Contributors" to include all names in "ChangeLog"

---
 lib/Schedule/Cron.pm | 44 ++++++++++++++++++++++++++++++++++++++++++--
 1 file changed, 42 insertions(+), 2 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b2f3d64..f4788ca 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1913,14 +1913,14 @@ Sorry for that.
 
 =head1 LICENSE
 
-Copyright 1999-2011 Roland Huss.
+Copyright 1999-2022 Roland Huss.
 
 This library is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
 
 =head1 AUTHOR
 
-... roland
+Roland Huß <roland@consol.de>
 
 =head1 Contributors
 
@@ -1934,6 +1934,46 @@ Alexandr Ciornii <alexchorny@gmail.com>
 
 Nicholas Hubbard <nicholashubbard@posteo.net>
 
+=item *
+
+Bray Jones
+
+=item *
+
+Peter Vary
+
+=item *
+
+Philippe Verdret
+
+=item *
+
+Loic Paillotin
+
+=item *
+
+Andrew Danforth
+
+=item *
+
+Frank Mayer
+
+=item *
+
+Jamie McCarthy
+
+=item *
+
+Andy Ford
+
+=item *
+
+Eric Wilhelm
+
+=item *
+
+Clinton Gormley
+
 =back
 
 =cut
-- 
cgit v1.2.3


From 36554f2f5d838e44cfda8015effe98ad6c7c2303 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Thu, 6 Oct 2022 23:24:44 -0400
Subject: Merged "CHANGES" and "ChangeLog" into "Changes".

---
 CHANGES   | 110 ----------------------------------------------
 ChangeLog | 137 ---------------------------------------------------------
 Changes   | 147 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 147 insertions(+), 247 deletions(-)
 delete mode 100644 CHANGES
 delete mode 100644 ChangeLog
 create mode 100644 Changes

diff --git a/CHANGES b/CHANGES
deleted file mode 100644
index 69af8b4..0000000
--- a/CHANGES
+++ /dev/null
@@ -1,110 +0,0 @@
-1.03
-
-- Added option "processname" to set $0 to constant string (#9)
-- Added tests for options "processname", "processprefix", and "nostatus" (#10)
-
-1.02_2
-
-- Fixed typos in the documentation (#88521)
-- Fixed debug output slipped id (#83462)
-- Fixed crontab with empty lines (#75176)
-- Fixed skipping of jobs triggered at the same time when rescheduling (#70975)
-- Added option "timeshift" in order to shift the execution point a bit (#69177)
-- Made $? local in the reaper sub (#69110 and #69116)
-
-1.01
-
-- Fix for RT #56926 which causes systems without SIGCHLD to exit on
-  after 64 forked processes
-- Patch for Makefile.PL applied which seems to have problems after the 
-  reorganisation of the directory layout (RT #57914)
-- Fix for RT #63089 which left over a time-window of 1 sec where
-  Schedule::Cron could run havoc.
-- Fixes for RT #68530 ("Exposing too much information..."), #68450
-  ("Crash scheduling empty queue") and #68533 ("Thou shalt not REAP
-  what thou has not forked...") provided by tlhackque. Thanks a lot !
-- New options:
-  * loglevel: Tuning of logoutput
-  * nostatus: Avoid setting $0 to next schedule time
-  * sleep: Custom sleep() function between two calls
-  
-1.00
-
-- Fix for RT #54692 occured when removing an entry
-- Fixed #55741 with help from Clinton Gormley (a perl bug occuring when 
-  modyfing global hashes in an event handler)
-- Fixed RT #50325 which could cause an infinite loop when calculating
-  the next execution time
-- Further bug fixes.
-
-0.99
-
-- Fixed issue when switching back DST which can result into amok 
-  running jobs during this period. The behaviour for jobs triggered
-  within this rewinded hour is still not defined properly (yet). 
-
-0.98
-
-- New option 'after_job' for new() which allows for a callback run
-  after a job has been sucessfully run (RT #29040)
-- Argument logging is done using data dumper (RT #39499)
-- Private methods are now marked with '_'
-- Added tests for increased kwallitee
-- Switched over to Build.PL (Makefile.PL is still supported)
-- Fixed some time calculation times (e.g. for the first DST switch in
-  the year)  
-- Allow comments at the end of a crontab line
-
-0.97
-
-- Use POSIX only where available, otherwise fallback to an emulation
-  of waipid. 
-- Fixed bug when previous SIGCHLD handler was not a coderef, but a
-  String value like "DEFAULT" or "IGNORE"
-- Added tests
-- Made test more robust so they work now also on system without
-  alarm() functionality (Win32)
-
-0.96 
-
-- Applied patch for #4917 in order to be smarter to existing SIGCHLD
-  handler and to reap only own childs.
-
-0.95 
-
-- If a scheduled method in 'nofork' manipulates the execution queue with 
-  add_entry or delete_entry, it will be picked up during the next run. 
-- Clarified different behaviour of global variables within the fork/norfork 
-  mode in the documentation
-- Fixed warning about non-numeric arguments when sorting. 
-- Fixed bug which called to an undefined methods in a die-message
-- Pretty print a hashref in $0 if provided as argument and the 
-  prefix for the name to be shown in the process list can be configured
-  with the option "processprefix"
-
-0.9
-
-- Logging: It is now possible to add a reference to a custom logging
-  subroutine to the constructor which will be used for logging certain
-  events.
-- NoFork: The option 'nofork' prevents Cron.pm from creating a new
-  child process. Instead, the job is run within the current
-  process. You can use the 'skip' and 'catch' options to tune the
-  behaviour.
-- Seconds granularity: Cron times can now be specified up to the
-  second. 
-- Bugfix: Thinks like "*/5" now work like expected
-
-0.05   
-
-- Other bugfixes for parsedate problem with single digit hours/minutes 
-  and warnings if argumentlist of command to execute is empty
-
-0.03
-
-- Minor bug fixes (reaping of child processes improved, 
-  fixed regexp in get_next_execution_time())
-
-0.01
-
-- Initial Release
diff --git a/ChangeLog b/ChangeLog
deleted file mode 100644
index 16c5363..0000000
--- a/ChangeLog
+++ /dev/null
@@ -1,137 +0,0 @@
-2011-06-02  Roland Huss  <roland@consol.de>
-
-	* lib/Schedule/Cron.pm: Applied jumbo patch from RT #68533.
-	
-	* (_update_queue): fixed DST detection (RT #63089)	
-	
-2010-05-14  Roland Huss  <roland@consol.de>
-
-	* Released Version 1.00. This is considered to be the final 
-	  release. After 10+ years, Schedule::Cron is now feature complete, 
-	  only bug fixes might lead to an additional release. Thanks for
-	  your patience ;-)
-
-2009-09-12  Roland Huss  <roland@consol.de>
-
-	* Released Version 0.99
-
-2009-09-05  Roland Huss  <roland@consol.de>
-
-	* lib/Schedule/Cron.pm: Fixed issue for certain timeszone (like
-	PST8PDT) where a backward DST switch make Cron.pm running amok by
-	firing each job triggered in the extra hour without a delay
-	between. Thanks A LOT to Eric Wilhelm for spotting and analysing
-	this issue.
-	 
-2009-04-03  Roland Huss  <roland@consol.de>
-
-	* Released Version 0.98
-
-2009-03-24  Roland Huss  <roland@consol.de>
-
-	* lib/Schedule/Cron.pm (load_crontab): Allow comment at the end of 
-	a crontab line
-
-2009-03-23  Roland Huss  <roland@consol.de>
-
-	* lib/Schedule/Cron.pm (_calc_time): fixed some issues when
-	calculating times for '*' entries
-
-	* t/execution_time.t: Added test for checking proper DST behaviour
-
-2009-03-21  Roland Huss  <roland@consol.de>
-
-	* Cron.pm (_time_as_string): marked all private subs to start with '_'
-
-2009-03-20  Roland Huss  <roland@consol.de>
-
-	* t/pretty_print_args.t: Arguments are logged using Data::Dumper
-	in a terse format
-
-	* t/after_job.t: Added new option 'after_job' and test for it
-	which allows for a single callback after any job has been run.
-
-2006-11-27  Roland Huss  <roland@consol.de>
-
-	* Cron.pm (REAPER): Added support for plattforms where POSIX is
-	not available.
-	(run): Call previous childhandler only if it is a coderef
-
-2006-11-08  Roland Huss  <roland@consol.de>
-
-	* Cron.pm (run): Removed leading space when no process prefix is
-	used (for backwards compatibility)
-
-2006-11-05  Roland Huss  <roland@consol.de>
-
-	* CHANGES: added long forgotten patch for child process handling
-
-2006-11-05  Roland Huss  <roland@cpan.org>
-
-	* CHANGES: added patches and suggestions from
-	  - Andrew Danforth
-	  - Frank Mayer
-	  - Jamie McCarthy
-	  - Andy Ford
-
-	  Thanks !
-	
-2006-11-04  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm: Worked on:
-	  - Reexamination of crontabs entry in 'nofork' mode if someone
-	    has added a new entry
-
-2004-01-30  Roland Huss  <roland@cpan.org>
-
-	* t/entry.t (Module): added and extended tests
-
-2004-01-29  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm (add_entry): added heuristic for parsing crontab with 6
-	time columns
-
-2004-01-28  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm (new): added new options 'nofork', 'skip', 'catch' and
-	'log'
-	(get_next_execution_time): allow a sixth column for specifing the
-	second to start up
-
-2002-08-09  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm (get_next_execution_time): added recognition of "*/5"
-	notations (thanks to Loic Paillotin for spotting this problem)
-
-2002-04-02  Roland Huss  <roland@cpan.org>
-
-	* Released 0.0.5
-
-2000-07-05  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm: added patch from Lars Holokowo for working around a bug
-	in parsedate, which has trouble in parsing times in the form "3:1
-	2000/6/30". Added tests to check for those dates 
-
-2000-06-14  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm: added additional check for arguments to avoid warnings
-	as suggested by  David Parker
-
-	* Makefile.PL: added check for Time::ParseDate as suggested by
-	Philippe Verdret
-
-2000-06-12  Roland Huss  <roland@cpan.org>
-
-	* Cron.pm: Fixed bug in regexp splitting the crontab entry in
-	get_next_execution_time() report by Peter Vary
-
-2000-03-23  Roland Huss  <roland@cpan.org>
-	* Cron.pm: fixed problem when reaping childs: Now SIGCHLD handler
-	can handle more than one finished child at once (thanx to Bray
-	Jones for discovering this bug)
-	
-2000-01-02  Roland Huss  <roland@cpan.org>
-
-	* Initial release 0.001 
-
diff --git a/Changes b/Changes
new file mode 100644
index 0000000..5d4f152
--- /dev/null
+++ b/Changes
@@ -0,0 +1,147 @@
+1.04        UPCOMING
+
+- Merged "CHANGES" and "ChangeLog" into "Changes".
+- Added Roland (the authors) full name and email to the "Author" section of the
+  documentation.
+- Added all contributors named in "ChangeLog" to the "Contributors" section of
+  the documentation.
+
+1.03        2022-10-04
+
+- Added option "processname" to set $0 to constant string (#9)
+- Added tests for options "processname", "processprefix", and "nostatus" (#10)
+- Added "Contributors" section to the documentation.
+
+1.02_2      2013-12-19
+
+- Fixed typos in the documentation (#88521).
+- Fixed debug output slipped id (#83462).
+- Fixed crontab with empty lines (#75176).
+- Fixed skipping of jobs triggered at the same time when rescheduling (#70975).
+- Added option "timeshift" in order to shift the execution point a bit
+  (#69177).
+- Made $? local in the reaper sub (#69110 and #69116).
+
+1.01        2011-06-06
+
+- Fix for RT #56926 which causes systems without SIGCHLD to exit on after 64
+  forked processes.
+- Patch for Makefile.PL applied which seems to have problems after the 
+  reorganisation of the directory layout (RT #57914).
+- Fix for RT #63089 which left over a time-window of 1 sec where Schedule::Cron
+  could run havoc.
+- Fixes for RT #68530 ("Exposing too much information..."), #68450
+  ("Crash scheduling empty queue") and #68533 ("Thou shalt not REAP
+  what thou has not forked...") provided by tlhackque. Thanks a lot!
+- New options:
+  * loglevel: Tuning of logoutput.
+  * nostatus: Avoid setting $0 to next schedule time.
+  * sleep: Custom sleep() function between two calls.
+  
+1.00        2010-05-14
+
+- Fix for RT #54692 occured when removing an entry.
+- Fixed #55741 with help from Clinton Gormley (a perl bug occuring when
+  modyfing global hashes in an event handler).
+- Fixed RT #50325 which could cause an infinite loop when calculating the next
+  execution time
+- Further bug fixes.
+
+0.99        2009-09-12
+
+* lib/Schedule/Cron.pm: Fixed issue for certain timeszone (like PST8PDT) where
+  a backward DST switch make Cron.pm running amok by firing each job triggered
+  in the extra hour without a delay between. Thanks A LOT to Eric Wilhelm for
+  spotting and analysing this issue.
+
+0.98        2009-04-03
+
+- New option 'after_job' for new() which allows for a callback run after a job
+  has been sucessfully run (RT #29040).
+- Argument logging is done using data dumper (RT #39499).
+- Private methods are now marked with '_'.
+- Added tests for increased kwallitee.
+- Switched over to Build.PL (Makefile.PL is still supported).
+- Fixed some time calculation times (e.g. for the first DST switch in the
+  year). 
+- Allow comments at the end of a crontab line.
+* lib/Schedule/Cron.pm (_calc_time): fixed some issues when calculating times
+  for '*' entries.
+* t/execution_time.t: Added test for checking proper DST behaviour.
+* lib/Schedule/Cron.pm (load_crontab): Allow comment at the end of a crontab
+  line.
+
+0.97        2006-11-27
+
+- Use POSIX only where available, otherwise fallback to an emulation of waipid.
+- Fixed bug when previous SIGCHLD handler was not a coderef, but a tring value
+  like "DEFAULT" or "IGNORE"
+- Added tests
+- Made test more robust so they work now also on system without alarm()
+  functionality (Win32).
+- Cron.pm:(run): Removed leading space when no process prefix is used (for
+  backwards compatibility).
+
+0.96        2006-11-05
+
+- Applied patch for #4917 in order to be smarter to existing SIGCHLD handler
+  and to reap only own childs.
+
+0.95        2006-11-05
+
+- If a scheduled method in 'nofork' manipulates the execution queue with 
+  add_entry or delete_entry, it will be picked up during the next run. 
+- Clarified different behaviour of global variables within the fork/nofork mode
+  in the documentation.
+- Fixed warning about non-numeric arguments when sorting. 
+- Fixed bug which called to an undefined methods in a die-message
+- Pretty print a hashref in $0 if provided as argument and the 
+  prefix for the name to be shown in the process list can be configured
+  with the option "processprefix".
+- CHANGES: added patches and suggestions from
+  - Andrew Danforth
+  - Frank Mayer
+  - Jamie McCarthy
+  - Andy Ford
+- Cron.pm: Worked on: Reexamination of crontabs entry in 'nofork' mode if
+  someone has added a new entry.
+
+0.9         2005-01-03
+
+- Logging: It is now possible to add a reference to a custom logging
+  subroutine to the constructor which will be used for logging certain
+  events.
+- NoFork: The option 'nofork' prevents Cron.pm from creating a new child
+  process. Instead, the job is run within the current process. You can use the
+  'skip' and 'catch' options to tune the behaviour.
+- Cron.pm: added new options 'nofork', 'skip', 'catch' and 'log'.
+- t/entry.t (Module): added and extended tests.
+- Cron.pm (add_entry): added heuristic for parsing crontab with 6 time columns.
+- (get_next_execution_time): allow a sixth column for specifing the second to
+  start up.
+- Cron.pm:(get_next_execution_time): added recognition of "*/5" notations
+  (thanks to Loic Paillotin for spotting this problem).
+
+0.05        2002-04-02
+
+- Other bugfixes for parsedate problem with single digit hours/minutes 
+  and warnings if argumentlist of command to execute is empty.
+- Cron.pm: added patch from Lars Holokowo for working around a bug in
+  parsedate, which has trouble in parsing times in the form "3:1 2000/6/30".
+  Added tests to check for those dates.
+- Cron.pm: added additional check for arguments to avoid warnings as suggested
+  by David Parker.
+- Makefile.PL: added check for Time::ParseDate as suggested by
+  Philippe Verdret.
+
+0.03        2000-06-12
+
+- Cron.pm: Fixed bug in regexp splitting the crontab entry in
+  get_next_execution_time() report by Peter Vary.
+- Cron.pm: Fixed problem when reaping childs: Now SIGCHLD handler can handle
+  more than one finished child at once (thanx to Bray Jones for discovering
+  this bug).
+
+0.01        2000-01-09
+
+- Initial Release
-- 
cgit v1.2.3


From 41620a2c82ca0375196d2b0e959828d2671c283d Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Fri, 7 Oct 2022 13:30:35 -0400
Subject: Updated changes

---
 Changes | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/Changes b/Changes
index 5d4f152..1d468e9 100644
--- a/Changes
+++ b/Changes
@@ -1,10 +1,8 @@
 1.04        UPCOMING
 
 - Merged "CHANGES" and "ChangeLog" into "Changes".
-- Added Roland (the authors) full name and email to the "Author" section of the
-  documentation.
-- Added all contributors named in "ChangeLog" to the "Contributors" section of
-  the documentation.
+- Updated documenation sections: "AUTHORS", "CONTRIBUTORS", and
+  "COPYRIGHT AND LICENSE"
 
 1.03        2022-10-04
 
-- 
cgit v1.2.3


From ceede9160f2fe6bb653e9a1d6b7e037719338d8c Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Fri, 7 Oct 2022 13:30:43 -0400
Subject: Updated docs for "AUTHORS", "CONTRIBUTORS", and "COPYRIGHT"

---
 lib/Schedule/Cron.pm | 42 +++++++++++++++++++++++-------------------
 1 file changed, 23 insertions(+), 19 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index f4788ca..b563827 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1911,17 +1911,12 @@ hero is coming along and will fix this, but this is probably not me ;-)
 
 Sorry for that.
 
-=head1 LICENSE
-
-Copyright 1999-2022 Roland Huss.
-
-This library is free software; you can redistribute it and/or
-modify it under the same terms as Perl itself.
-
-=head1 AUTHOR
+=head1 AUTHORS
 
 Roland Huß <roland@consol.de>
 
+Currently maintained by Nicholas Hubbard <nicholashubbard@posteo.net>
+
 =head1 Contributors
 
 =over 4
@@ -1932,50 +1927,59 @@ Alexandr Ciornii <alexchorny@gmail.com>
 
 =item *
 
-Nicholas Hubbard <nicholashubbard@posteo.net>
+Andrew Danforth
 
 =item *
 
-Bray Jones
+Andy Ford
 
 =item *
 
-Peter Vary
+Bray Jones
 
 =item *
 
-Philippe Verdret
+Clinton Gormley
 
 =item *
 
-Loic Paillotin
+Eric Wilhelm
 
 =item *
 
-Andrew Danforth
+Frank Mayer
 
 =item *
 
-Frank Mayer
+Jamie McCarthy
 
 =item *
 
-Jamie McCarthy
+Loic Paillotin
 
 =item *
 
-Andy Ford
+Nicholas Hubbard <nicholashubbard@posteo.net>
 
 =item *
 
-Eric Wilhelm
+Peter Vary
 
 =item *
 
-Clinton Gormley
+Philippe Verdret
 
 =back
 
+=head1 COPYRIGHT AND LICENSE
+
+Copyright (c) 1999-2013 Roland Huss.
+
+Copyright (c) 2022 Nicholas Hubbard.
+
+This library is free software; you can redistribute it and/or
+modify it under the same terms as Perl itself.
+
 =cut
 
 1;
-- 
cgit v1.2.3


From c0f9cf5b1747d8b37b1b9ba4cd7095e73ea3daee Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Fri, 7 Oct 2022 13:31:40 -0400
Subject: Updated Roland's last name.

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b563827..ab5f5fc 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1973,7 +1973,7 @@ Philippe Verdret
 
 =head1 COPYRIGHT AND LICENSE
 
-Copyright (c) 1999-2013 Roland Huss.
+Copyright (c) 1999-2013 Roland Huß.
 
 Copyright (c) 2022 Nicholas Hubbard.
 
-- 
cgit v1.2.3


From 6497cce944b07865240cc07103978b98d49d3994 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Fri, 7 Oct 2022 13:33:59 -0400
Subject: Capatilize CONTRIBUTORS

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index ab5f5fc..754f33f 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1917,7 +1917,7 @@ Roland Huß <roland@consol.de>
 
 Currently maintained by Nicholas Hubbard <nicholashubbard@posteo.net>
 
-=head1 Contributors
+=head1 CONTRIBUTORS
 
 =over 4
 
-- 
cgit v1.2.3


From dceb24e227f008fb04b8bc963aa8e05865c16edd Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Fri, 7 Oct 2022 13:57:58 -0400
Subject: Updated copyright

---
 README | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/README b/README
index b861f44..53ca7f1 100644
--- a/README
+++ b/README
@@ -151,10 +151,12 @@ Please note also, that the active development for this module has been
 stopped since it is considered  to be feature complete. Bugs and minor
 (external) additions will be added from time to time, though.
 
-LICENSE
--------
+COPYRIGHT AND LICENSE
+---------------------
 
-Copyright 1999-2013 Roland Huss.
+Copyright (c) 1999-2013 Roland Huß.
+
+Copyright (c) 2022 Nicholas Hubbard.
 
 This library is  free software; you can redistribute  it and/or modify
 it under the same terms as Perl itself.
-- 
cgit v1.2.3


From 718aae1337a1126fc68c6b4d0e0846965c5b092c Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Sat, 8 Oct 2022 10:37:50 -0400
Subject: Spelling

---
 README | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/README b/README
index 53ca7f1..fe6cd60 100644
--- a/README
+++ b/README
@@ -99,7 +99,7 @@ refer to the documentation for further reading.
 INSTALLATION
 ------------
 
-Installation can be don either in the old fashioned way
+Installation can be done either in the old fashioned way
 
    perl Makefile.PL
    make
@@ -158,7 +158,7 @@ Copyright (c) 1999-2013 Roland Huß.
 
 Copyright (c) 2022 Nicholas Hubbard.
 
-This library is  free software; you can redistribute  it and/or modify
+This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
 
 Enjoy it...
-- 
cgit v1.2.3


From 52166cd2655e97d36439f2281b319847cf002da4 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Sat, 8 Oct 2022 10:44:12 -0400
Subject: Merged "CHANGES" and "ChangeLog" into "Changes"

---
 MANIFEST | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/MANIFEST b/MANIFEST
index 24de02e..b6161f9 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,6 +1,5 @@
 Build.PL
-ChangeLog
-CHANGES
+Changes
 examples/simple.pl
 examples/cron.tab
 examples/custom_sleep.pl
-- 
cgit v1.2.3


From 871f32497d10aaf3575c51a04a6438dd379003dd Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Sat, 8 Oct 2022 10:47:06 -0400
Subject: Added release date for 1.04

---
 Changes | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Changes b/Changes
index 1d468e9..849f7e3 100644
--- a/Changes
+++ b/Changes
@@ -1,4 +1,4 @@
-1.04        UPCOMING
+1.04        2022-10-08
 
 - Merged "CHANGES" and "ChangeLog" into "Changes".
 - Updated documenation sections: "AUTHORS", "CONTRIBUTORS", and
-- 
cgit v1.2.3


From 87ef5fd3ac2bf583b87c5c4be021ed4cb7ab4d71 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Sat, 8 Oct 2022 10:50:34 -0400
Subject: Bumped version to 1.04

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 754f33f..376ab2d 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -79,7 +79,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.03";
+$VERSION = "1.04";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 47dcd36a2083fc195888453f2024e635c66ea805 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 12:10:55 -0500
Subject: explictly UTF8 encode POD

---
 lib/Schedule/Cron.pm | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 376ab2d..b39011a 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1,5 +1,7 @@
 #!/usr/bin/perl -w
 
+=encoding utf8
+
 =head1 NAME
 
 Cron - cron-like scheduler for Perl subroutines
@@ -1975,7 +1977,7 @@ Philippe Verdret
 
 Copyright (c) 1999-2013 Roland Huß.
 
-Copyright (c) 2022 Nicholas Hubbard.
+Copyright (c) 2022-2023 Nicholas Hubbard.
 
 This library is free software; you can redistribute it and/or
 modify it under the same terms as Perl itself.
@@ -1983,7 +1985,3 @@ modify it under the same terms as Perl itself.
 =cut
 
 1;
-
-
-
-
-- 
cgit v1.2.3


From 71894c4b26a3d29b005889c8c467ba464b3c2f5b Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 12:45:01 -0500
Subject: Spelling fixes

---
 lib/Schedule/Cron.pm | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index b39011a..dc0cdd0 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -254,7 +254,7 @@ string)
 Don't fork when starting the scheduler. Instead, the jobs are executed within
 current process. In your executed jobs, you have full access to the global
 variables of your script and hence might influence other jobs running at a
-different time. This behaviour is fundamentally different to the 'fork' mode,
+different time. This behavior is fundamentally different to the 'fork' mode,
 where each jobs gets its own process and hence a B<copy> of the process space,
 independent of each other job and the main process. This is due to the nature
 of the  C<fork> system call. 
@@ -574,7 +574,7 @@ Any additional parameters will be given as arguments to the subroutine to be
 executed.  You can also specify a reference to an array instead of a list of
 parameters.
 
-You can also use a named parameter list provided as an hashref.  The named
+You can also use a named parameter list provided as an hashref. The named
 parameters recognized are:
 
 =over
@@ -692,7 +692,7 @@ refer to the documentation of the method C<add_entry>.
 
 The order index of each entry can be used within C<update_entry>, C<get_entry>
 and C<delete_entry>. But be aware, when you are deleting an entry, that you
-have to refetch the list, since the order will have changed.
+have to re-fetch the list, since the order will have changed.
 
 Note that these entries are returned by value and were obtained from the
 internal list by a deep copy. I.e. you are free to modify it, but this won't
@@ -1359,7 +1359,7 @@ sub _execute
   exit unless $cfg->{nofork};
 }
 
-# Udate the scheduler queue with a new entry
+# Update the scheduler queue with a new entry
 sub _update_queue 
 { 
     my $self = shift;
@@ -1888,8 +1888,8 @@ skipped. Any job which triggers in this skipped hour will be fired in the
 next hour. So, when the DST switch goes from 2:00 to 3:00 a job which is
 scheduled for 2:43 will be executed at 3:43.
 
-For the reverse backwards switch later in the year, the behaviour is
-undefined. Two possible behaviours can occur: For jobs triggered in short
+For the reverse backwards switch later in the year, the behavior is
+undefined. Two possible behaviors can occur: For jobs triggered in short
 intervals, where the next execution time would fire in the extra hour as well,
 the job could be executed again or skipped in this extra hour. Currently,
 running C<Schedule::Cron> in C<MET> would skip the extra job, in C<PST8PDT> it
@@ -1901,14 +1901,14 @@ of the first occurrence for C<PST8PDT> and for C<MET> it returns the second
 occurrence. Unfortunately, there is no way to specify I<which> entry
 L<Time::ParseDate> should pick (until now). Of course, after all, this is
 obviously not L<Time::ParseDate>'s fault, since a simple date specification
-within the DST backswitch period B<is> ambiguous. However, it would be nice if
-the parsing behaviour of L<Time::ParseDate> would be consistent across time
+within the DST back-switch period B<is> ambiguous. However, it would be nice if
+the parsing behavior of L<Time::ParseDate> would be consistent across time
 zones (a ticket has be raised for fixing this). Then L<Schedule::Cron>'s
-behaviour within a DST backward switch would be consistent as well.
+behavior within a DST backward switch would be consistent as well.
 
 Since changing the internal algorithm which worked now for over ten years would
 be too risky and I don't see any simple solution for this right now, it is
-likely that this I<undefined> behaviour will exist for some time. Maybe some
+likely that this I<undefined> behavior will exist for some time. Maybe some
 hero is coming along and will fix this, but this is probably not me ;-)
 
 Sorry for that.
-- 
cgit v1.2.3


From f41adcf9543f96681e5bff823f5b80edc37c267a Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 12:45:52 -0500
Subject: Bumped version

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index dc0cdd0..43ff1f5 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -81,7 +81,7 @@ BEGIN {
 }
 
 
-$VERSION = "1.04";
+$VERSION = "1.05";
 
 our $DEBUG = 0;
 my %STARTEDCHILD = ();
-- 
cgit v1.2.3


From 5968f3b9ac5e691eab5ff63556041836342de570 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:25:31 -0500
Subject: Remove support for Module::Build

---
 Build.PL | 35 -----------------------------------
 1 file changed, 35 deletions(-)
 delete mode 100644 Build.PL

diff --git a/Build.PL b/Build.PL
deleted file mode 100644
index e35c9e1..0000000
--- a/Build.PL
+++ /dev/null
@@ -1,35 +0,0 @@
-#!/usr/bin/perl
-use Module::Build;
-my $build = Module::Build->new
-  (
-   module_name => "Schedule::Cron",
-   dist_author => 'Roland Huss (roland@cpan.org)',
-   abstract => 'Cron-like scheduler for Perl subroutines',
-   distribution_type => 'module',
-   installdirs => 'site',
-
-   license => "perl",
-   
-   requires => {
-                "Time::ParseDate" => "2011.0505",
-                "Data::Dumper" => "0"
-               },
-   
-   build_requires => {
-                      "Test::More" => "0",
-                      "Test" => "0",
-                     },                       
-   keywords => [  "Cron", "Scheduler", "Job" ],
-  meta_merge => {
-    resources => {
-      repository => 'http://github.com/rhuss/schedule-cron',
-    },
-  },
-   provides => {
-                "Schedule::Cron" => {
-                               file =>  "lib/Schedule/Cron.pm"
-                              }
-               },
-   configure_requires => { 'Module::Build' => 0}
-  );
-$build->create_build_script;
-- 
cgit v1.2.3


From d10df1c29e85d4e274fc0ed399a3457e40445fe4 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:25:44 -0500
Subject: Fix bug for undefined warning (145506)

---
 lib/Schedule/Cron.pm | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/lib/Schedule/Cron.pm b/lib/Schedule/Cron.pm
index 43ff1f5..b7cd7a4 100644
--- a/lib/Schedule/Cron.pm
+++ b/lib/Schedule/Cron.pm
@@ -1166,7 +1166,7 @@ sub get_next_execution_time
           else 
           {
               $t = $ALPHACONV[$i]{lc $t} if $t !~ /^(\d+|\*)$/;
-              $t = $LOWMAP[$i]{$t} if exists($LOWMAP[$i]{$t});
+              $t = $LOWMAP[$i]{$t} if( defined $t && exists($LOWMAP[$i]{$t}) );
               
               die "Invalid cronentry '",$cron_entry->[$i],"'" 
                 if (!defined($t) || ($t ne '*' && ($t < $RANGES[$i][0] || $t > $RANGES[$i][1])));
-- 
cgit v1.2.3


From 693bc7de22aebe6e92b7ada7f078f3c934c48be3 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:27:09 -0500
Subject: Formatting fixes

---
 README | 83 +++++++++++++++++++++++++++++-------------------------------------
 1 file changed, 37 insertions(+), 46 deletions(-)

diff --git a/README b/README
index fe6cd60..c531368 100644
--- a/README
+++ b/README
@@ -1,30 +1,29 @@
 			    Schedule::Cron
 			    ==============
 
-This module provides  a simple but complete cron  like scheduler.  I.e
-this modules can be  used for periodically executing Perl subroutines.
-The  dates  and  parameters  for  the subroutines  to  be  called  are
+This module provides a simple but complete cron like scheduler. I.e
+this modules can be used for periodically executing Perl subroutines.
+The dates and parameters for the subroutines to be called are
 specified with a format known as crontab entry (see manpage crontab(5)
 or documentation of Schedule::Cron).
 
-The   philosophy  behind   Schedule::Cron  is   to   call  subroutines
-periodically from  within one single  Perl program instead  of letting
-cron  trigger several  (possibly different)  Perl  scripts. Everything
-under  one  roof.  Furthermore  Schedule::Cron  provides mechanism  to
+The philosophy behind Schedule::Cron is to call subroutines
+periodically from within one single Perl program instead of letting
+cron trigger several (possibly different) Perl scripts. Everything
+under one roof. Furthermore Schedule::Cron provides mechanism to
 create crontab entries dynamically, which isn't that easy with cron.
 
-Schedule::Cron  knows  about  all   extensions  (well,  at  least  all
+Schedule::Cron knows about all extensions (well, at least all
 extensions I'm aware of, i.e those  of the so called "Vixie" cron) for
-crontab entries like ranges  including 'steps', specification of month
+crontab entries like ranges including 'steps', specification of month
 and days of the week by name or coexistence of lists and ranges in the
-same field. And  even a bit more (like lists  and ranges with symbolic
+same field. And even a bit more (like lists and ranges with symbolic
 names).
 
-This module is rather effective concerning system load.  It calculates
-the execution  dates in advance and  will sleep until  those dates are
-reached (and  wont wake  up every minute  to check for  execution like
-cron).   However, it  relies on  the accuracy  of your  sleep() system
-call.
+This module is rather effective concerning system load. It calculates
+the execution dates in advance and will sleep until those dates are
+reached (and wont wake up every minute to check for execution like
+cron). However, it relies on the accuracy of your sleep() system call.
 
 EXAMPLES
 --------
@@ -72,79 +71,72 @@ EXAMPLES
 PREREQUISITES
 -------------
 
-In order  to install and use  this package you will  need Perl version
-5.005  or better.   Furthermore  you need  the module  Time::ParseDate
+In order to install and use this package you will need Perl version
+5.005 or better. Furthermore you need the module Time::ParseDate
 (contained in the Time-modules-xx.xxxxx) available on CPAN.
 
 You need a fork()-aware Perl for dispatching the cron jobs. This might
-change in the future. On systems  without a fork() system call you can
+change in the future. On systems without a fork() system call you can
 use the 'nofork' option to run your jobs within the current process.
 
 OS-DEPENDENCIES
 ---------------
 
 Schedule::Cron was tested on a Redhat Linux-Box, but it should work on
-any UNIX Box.  In depends on some original UNIX system calls for
+any UNIX Box. In depends on some original UNIX system calls for
 starting jobs and detaching itself to the background:
 
   * It uses fork() for starting jobs
   * For  detaching it  uses either  setsid (POSIX)  or the  ioctl call
     TIOCNOTTY
 
-If the  system calls mentioned  above are not available  (which should
-hapen nowadays only  under rare circumstances), you can  still use the
+If the system calls mentioned above are not available (which should
+hapen nowadays only under rare circumstances), you can still use the
 'nofork' option to run all jobs within a single process/thread. Please
 refer to the documentation for further reading.
 
 INSTALLATION
 ------------
 
-Installation can be done either in the old fashioned way
+Installation can be done the old fashioned way
 
    perl Makefile.PL
    make
    make test
    make install
 
-or alternatively with Module::Build
-
-   perl Build.PL
-   ./Build 
-   ./Build test
-   ./Build install
-
-See the  documentation for  Schedule::Cron for a  detailed description
+See the documentation for Schedule::Cron for a detailed description
 and further usage examples.
 
 REPORTING BUGS
 --------------
 
-If  you  meet  a  bug  (say   hello  to  it  ;-),  open  a  ticket  at
+If you meet a bug (say hello to it ;-), open a ticket at
 https://rt.cpan.org/Ticket/Create.html?Queue=Schedule-Cron.          
 
-In addition of  a problem description, please add  a short description
-of you  OS, your Perl version  and the version  of Time::ParseDate you
-are using.  If some of the  provided tests fail, include the output of
+In addition of a problem description, please add a short description
+of you OS, your Perl version and the version of Time::ParseDate you
+are using. If some of the provided tests fail, include the output of
 'make test TEST_VERBOSE=1' as well.
 
-If you suspect,  that the date calculation of  the next execution time
-is buggy, please  use the following interactive command  to generate a
+If you suspect, that the date calculation of the next execution time
+is buggy, please use the following interactive command to generate a
 bug report.
 
    perl -MSchedule::Cron -e 'bug Schedule::Cron'
 
-You will be asked for a  reference time (default: the current time), a
-crontab  date  pattern  (with  five  columns) and  the  expected  next
-execution date  (relative to  the reference time).   The dates  can be
-specified in  a format understood by  'parsedate' from Time::ParseDate
-(like 'now  + 5  days').  Please include  the output of  this command.
+You will be asked for a reference time (default: the current time), a
+crontab  date pattern (with five columns) and the expected next
+execution date (relative to  the reference time). The dates can be
+specified in a format understood by 'parsedate' from Time::ParseDate
+(like 'now + 5 days'). Please include the output of this command.
 
 REPOSITORY
 ----------
 
-Schedule::Cron's         source          is         located         at
-https://github.com/rhuss/schedule-cron  Please feel  free  to send  me
-pull requests if they apply  to the license below.  Also, don't forget
+Schedule::Cron's source is located at
+https://github.com/rhuss/schedule-cron Please feel free to send me
+pull requests if they apply to the license below. Also, don't forget
 documentation and tests.
 
 Please note also, that the active development for this module has been
@@ -156,11 +148,10 @@ COPYRIGHT AND LICENSE
 
 Copyright (c) 1999-2013 Roland Huß.
 
-Copyright (c) 2022 Nicholas Hubbard.
+Copyright (c) 2022-2023 Nicholas Hubbard.
 
 This library is free software; you can redistribute it and/or modify
 it under the same terms as Perl itself.
 
 Enjoy it...
                                             ...roland (roland@cpan.org)
-
-- 
cgit v1.2.3


From 9a884136b493453cdb1c643eb4cd33c72817ce04 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:34:17 -0500
Subject: Removed META.yml for a EU::MM autogenerated one

---
 META.yml | 28 ----------------------------
 1 file changed, 28 deletions(-)
 delete mode 100644 META.yml

diff --git a/META.yml b/META.yml
deleted file mode 100644
index d2e0ab9..0000000
--- a/META.yml
+++ /dev/null
@@ -1,28 +0,0 @@
----
-abstract: 'cron-like scheduler for Perl subroutines'
-author:
-  - 'Roland Huss (roland@cpan.org)'
-build_requires:
-  Test: '0'
-  Test::More: '0'
-configure_requires:
-  Module::Build: '0'
-dynamic_config: 0
-generated_by: 'Module::Build version 0.4231, CPAN::Meta::Converter version 2.150010'
-license: perl
-meta-spec:
-  url: http://module-build.sourceforge.net/META-spec-v1.4.html
-  version: '1.4'
-name: Schedule-Cron
-provides:
-  Schedule::Cron:
-    file: lib/Schedule/Cron.pm
-    version: '1.03'
-requires:
-  Data::Dumper: '0'
-  Time::ParseDate: '2011.0505'
-resources:
-  license: http://dev.perl.org/licenses/
-  repository: http://github.com/rhuss/schedule-cron
-version: '1.03'
-x_serialization_backend: 'CPAN::Meta::YAML version 0.018'
-- 
cgit v1.2.3


From ec17146d83b5bee81139aaaae51fdf94be511fd2 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:35:38 -0500
Subject: Removed META.yml for a EU::MM autogenerated one

---
 Makefile.PL | 1 -
 1 file changed, 1 deletion(-)

diff --git a/Makefile.PL b/Makefile.PL
index e99b1dd..8bfd9c9 100644
--- a/Makefile.PL
+++ b/Makefile.PL
@@ -1,7 +1,6 @@
 use ExtUtils::MakeMaker;
 WriteMakefile
   (
-   NO_META => 1,
    NAME => "Schedule::Cron",
    VERSION_FROM => "lib/Schedule/Cron.pm",
    ($] >= 5.005
-- 
cgit v1.2.3


From 1654f8dc7bbb6be5bbc9785970e3434a3d5ce40b Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:36:10 -0500
Subject: No longer support Module::Build

---
 MANIFEST | 1 -
 1 file changed, 1 deletion(-)

diff --git a/MANIFEST b/MANIFEST
index b6161f9..40fd72d 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -1,4 +1,3 @@
-Build.PL
 Changes
 examples/simple.pl
 examples/cron.tab
-- 
cgit v1.2.3


From 8a67b1cda239c41e6140bfc83d0b22faa8bfc8f5 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:36:49 -0500
Subject: Removed META.yml for a EU::MM autogenerated one

---
 MANIFEST | 1 -
 1 file changed, 1 deletion(-)

diff --git a/MANIFEST b/MANIFEST
index 40fd72d..9b2ff4f 100644
--- a/MANIFEST
+++ b/MANIFEST
@@ -5,7 +5,6 @@ examples/custom_sleep.pl
 lib/Schedule/Cron.pm
 Makefile.PL
 MANIFEST			This list of files
-META.yml
 README
 t/after_job.t
 t/callbackreschedule.t
-- 
cgit v1.2.3


From a6634a940ff5d637ad76c06b7c1f70abaa4b3815 Mon Sep 17 00:00:00 2001
From: Nicholas Hubbard <nicholashubbard@posteo.net>
Date: Wed, 22 Feb 2023 22:37:49 -0500
Subject: Updated for version 1.05

---
 Changes | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/Changes b/Changes
index 849f7e3..e84eb08 100644
--- a/Changes
+++ b/Changes
@@ -1,3 +1,10 @@
+1.05        2023-02-22
+- Fixed POD error from using UTF8 char without setting =encoding (ticket 144709)
+- Fixed minor undefined warning bug (ticket 145506)
+- Fixed spelling and grammar issues in the documentation
+- Removed handwritten META.yml in favor of EU::MM generated META.yml
+- Removed support for Module::Build in favor of ExtUtils::MakeMaker
+
 1.04        2022-10-08
 
 - Merged "CHANGES" and "ChangeLog" into "Changes".
-- 
cgit v1.2.3