whenever 0.9.2 → 0.10.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9b7b1f246b22c910d7f50418153572714548f3a7
-  data.tar.gz: cc253c6228c7e36d7f07032d5272e442d2eb6b08
+  metadata.gz: 9c8fe56b21ffa57026a2b944ae208bea62a9d7e9
+  data.tar.gz: 543d704698ab03d944679daa1e85bee1b3936286
 SHA512:
-  metadata.gz: bccd024f09f270d95b331f2c7177dad4914865eaacb5f83392f12a30fd1272cdfb3179dfaa731d84d63796a1f12a00d38b612b220fd46373a06ed7d0eeb0c90b
-  data.tar.gz: 8cfcfb3ae75cf378878631528a397618f369743639e34e51a63a53b6ee0c59c919969cbb7152e59775a46478fb0b3232ec228a69c1b968668cb77a360a734106
+  metadata.gz: 3d0bd440a4beab5ecde93ccb91fad7cf5b2bf2ffe14a376ad24392fe5b4a3d53ba1d7ce15a53d2debc3b639a35f609436d21ab78de16b99a857fe1e16ed8bed1
+  data.tar.gz: 4bb8692d2f7130e45d80fc05a6a54609fd160155014eae330da8f0fc9ed97e9338d523282cd4f8ec197531231493bd04d2409a3d7a6bbc57761ff6ad0ff7f422

data/.gitignore

@@ -3,3 +3,4 @@ pkg
 doc
 .*.sw[a-z]
 Gemfile.lock
+gemfiles/*.lock

data/.travis.yml

@@ -1,11 +1,21 @@
 language: ruby
+
+before_install:
+  - gem install bundler
+
 rvm:
-  - 1.8.7
-  - 1.9.2
   - 1.9.3
   - 2.0.0
-  - 2.1.0
-  - ree
-  - jruby
-  - jruby-18mode
-  - jruby-19mode
+  - 2.1.10
+  - 2.2.6
+  - 2.3.3
+  - 2.4.0
+  - jruby-9.1.9.0
+
+gemfile:
+  - Gemfile
+  - gemfiles/activesupport4.1.gemfile
+  - gemfiles/activesupport4.2.gemfile
+env:
+  global:
+    - JRUBY_OPTS=--debug

data/CHANGELOG.md

@@ -1,3 +1,66 @@
+### develop
+
+### 0.10.0 / November 19, 2017
+
+* Modify wheneverize to allow for the creating of 'config' directory when not present
+
+* Add --crontab-command to whenever binary for overriding the crontab command. [Martin Grandrath]
+
+* Allow setting the path within which Capistrano will execute whenever. [Samuel Johnson](https://github.com/javan/whenever/pull/619)
+
+* Allow the use of string literals for month and day-of-week in raw cron syntax.. [Potamianos Gregory](https://github.com/javan/whenever/pull/711)
+
+* Include Capistrano default environment variables when executing Whenever. [Karl Li](https://github.com/javan/whenever/pull/719)
+
+* Allow configuring an alternative schedule file in Capistrano. [Shinichi Okamoto](https://github.com/javan/whenever/pull/666)
+
+### 0.9.7 / June 14, 2016
+
+* Restore compatibility with Capistrano v3; it has a bug which we have to work around [Ben Langfeld, Chris Gunther, Shohei Yamasaki]
+
+### 0.9.6 / June 13, 2016
+
+* Bypass symlinks when loading Capistrano v3 code, since these symlinks don't work in recent gem releases [Justin Ramos]
+
+### 0.9.5 / June 12, 2016
+
+* Improve documentation [Ben Langfeld, Spencer Fry]
+
+* Properly support Solaris / SmartOS [Steven Williamson]
+
+* Drop support for Ruby < 1.9.3. Test newer Ruby versions. [Javan Makhmali, Bartłomiej Kozal]
+
+* Suport Ruby 2.3.0 and Rails 4 [Vincent Boisard]
+
+* Set `RAILS_ENV` correctly in schedule when writing crontab from Capistrano [Ben Langfeld, Lorenzo Manacorda]
+
+* Minor refactoring, avoidance of Ruby warnings, etc [Ben Langfeld, DV Dasari]
+
+* Correctly pass through date expressions (e.g. `1.day`) inside job definitions [Rafael Sales]
+
+* Prevent writing invalid cron strings [Danny Fallon, Ben Langfeld]
+
+* Execute runner with `bundle exec` to ensure presence of app dependencies [Judith Roth]
+
+
+### 0.9.4 / October 24, 2014
+
+* Fix duplicated command line arguments when deploying to multiple servers with Cap 3. [betesh]
+
+* Set `whenever_environment` to the current stage before defaulting to production in Cap 3 tasks. [Karthik T]
+
+
+### 0.9.3 / October 5, 2014
+
+* Drop ActiveSupport dependency [James Healy, Javan Makhmali]
+
+* Drop shoulda for tests
+
+* Fix `whenever:clear_crontab` Cap 3 task [Javan Makhmali]
+
+* Avoid using tempfiles [ahoward]
+
+
 ### 0.9.2 / March 4, 2014
 
 * Fix issues generating arguments for `execute` in Capistrano 3 tasks. [Javan Makhmali]

data/Gemfile

@@ -2,8 +2,3 @@ source "http://rubygems.org"
 
 # Specify your gem's dependencies in whenever.gemspec
 gemspec
-
-if RUBY_VERSION < "1.9.3"
-  gem "activesupport", "< 4.0.0"
-  gem "shoulda-matchers", "<= 2.0.0"
-end

data/LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014 Javan Makhmali
+Copyright (c) 2017 Javan Makhmali
 
 Permission is hereby granted, free of charge, to any person
 obtaining a copy of this software and associated documentation

data/README.md

@@ -19,12 +19,36 @@ $ cd /apps/my-great-project
 $ wheneverize .
 ```
 
-This will create an initial `config/schedule.rb` file for you.
+This will create an initial `config/schedule.rb` file for you (as long as the config folder is already present in your project).
+
+### The `whenever` command
+
+```sh
+$ cd /apps/my-great-project
+$ whenever
+```
+
+This will simply show you your `schedule.rb` file converted to cron syntax. It does not read or write your crontab file; you'll need to do this in order for your jobs to execute:
+
+```sh
+$ whenever --update-crontab
+```
+
+Other commonly used options include:
+```sh
+$ whenever --user app # set a user as which to install the crontab
+$ whenever --load-file config/my_schedule.rb # set the schedule file
+$ whenever --crontab-command 'sudo crontab` # override the crontab command
+```
+
+You can list installed cron jobs using `crontab -l`.
+
+Run `whenever --help` for a complete list of options for selecting the schedule to use, setting variables in the schedule, etc.
 
 ### Example schedule.rb file
 
 ```ruby
-every 3.hours do
+every 3.hours do # 1.minute 1.day 1.week 1.month 1.year is also supported
   runner "MyModel.some_process"
   rake "my:rake:task"
   command "/usr/bin/my_great_command"
@@ -74,7 +98,7 @@ The default job types that ship with Whenever are defined like so:
 ```ruby
 job_type :command, ":task :output"
 job_type :rake,    "cd :path && :environment_variable=:environment bundle exec rake :task --silent :output"
-job_type :runner,  "cd :path && script/rails runner -e :environment ':task' :output"
+job_type :runner,  "cd :path && bin/rails runner -e :environment ':task' :output"
 job_type :script,  "cd :path && :environment_variable=:environment bundle exec script/:task :output"
 ```
 
@@ -96,6 +120,57 @@ Or set the job_template to nil to have your jobs execute normally.
 set :job_template, nil
 ```
 
+### Parsing dates and times
+
+Whenever uses the [Chronic](https://github.com/mojombo/chronic) gem to parse the specified dates and times.
+
+You can set your custom Chronic configuration if the defaults don't fit you.
+
+For example, to assume a 24 hour clock instead of the default 12 hour clock:
+
+```ruby
+set :chronic_options, :hours24 => true
+
+# By default this would run the job every day at 3am
+every 1.day, :at => '3:00' do
+  runner "MyModel.nightly_archive_job"
+end
+```
+
+You can see a list of all available options here: <https://github.com/mojombo/chronic/blob/master/lib/chronic/parser.rb>
+
+### Customize email recipient with the `MAILTO` environment variable
+
+Output from the jobs is sent to the email address configured in the `MAILTO` environment variable.
+
+There are many ways to further configure the recipient.
+
+Example: A global configuration, overriding the environment's value:
+
+```ruby
+env 'MAILTO', 'output_of_cron@example.com'
+
+every 3.hours do
+  command "/usr/bin/my_great_command"
+end
+```
+
+Example: A `MAILTO` configured for all the jobs in an interval block:
+
+```ruby
+every 3.hours, mailto: 'my_super_command@example.com'  do
+  command "/usr/bin/my_super_command"
+end
+```
+
+Example: A `MAILTO` configured for a single job:
+
+```ruby
+every 3.hours do
+  command "/usr/bin/my_super_command", mailto: 'my_super_command_output@example.com'
+end
+```
+
 ### Capistrano integration
 
 Use the built-in Capistrano recipe for easy crontab updates with deploys. For Capistrano V3, see the next section.
@@ -123,7 +198,7 @@ require "whenever/capistrano"
 
 The capistrano variable `:stage` should be the one holding your environment name. This will make the correct `:environment` available in your `schedule.rb`.
 
-If both your environments are on the same server you'll want to namespace them or they'll overwrite each other when you deploy:
+If both your environments are on the same server you'll want to namespace them, or they'll overwrite each other when you deploy:
 
 ```ruby
 set :whenever_environment, defer { stage }
@@ -131,6 +206,13 @@ set :whenever_identifier, defer { "#{application}_#{stage}" }
 require "whenever/capistrano"
 ```
 
+If you use a schedule at an alternative path, you may configure it like so:
+
+```ruby
+set :whenever_load_file, defer { "#{release_path}/somewhere/else/schedule.rb" }
+require "whenever/capistrano"
+```
+
 ### Capistrano V3 Integration
 
 In your "Capfile" file:
@@ -139,12 +221,14 @@ In your "Capfile" file:
 require "whenever/capistrano"
 ```
 
-Take a look at the load:defaults (bottom of file) task for options you can set. <http://github.com/javan/whenever/blob/master/lib/whenever/tasks/whenever.rake>. For example, to namespace the crontab entries by application and stage do this.
+Take a look at the [load:defaults task](https://github.com/javan/whenever/blob/master/lib/whenever/capistrano/v3/tasks/whenever.rake) (bottom of file) for options you can set. For example, to namespace the crontab entries by application and stage do this in your "config/deploy.rb" file:
 
 ```ruby
 set :whenever_identifier, ->{ "#{fetch(:application)}_#{fetch(:stage)}" }
 ```
 
+The Capistrano integration by default expects the `:application` variable to be set in order to scope jobs in the crontab.
+
 ### Capistrano roles
 
 The first thing to know about the new roles support is that it is entirely
@@ -153,10 +237,10 @@ different servers in your capistrano deployment, then you can safely stop readin
 now and everything should just work the same way it always has.
 
 When you define a job in your schedule.rb file, by default it will be deployed to
-all servers in the whenever_roles list (which defaults to [:db]).
+all servers in the whenever_roles list (which defaults to `[:db]`).
 
 However, if you want to restrict certain jobs to only run on subset of servers,
-you can add a :roles => [...] argument to their definitions. **Make sure to add
+you can add a `:roles => [...]` argument to their definitions. **Make sure to add
 that role to the whenever_roles list in your deploy.rb.**
 
 When you run `cap deploy`, jobs with a :roles list specified will only be added to
@@ -165,8 +249,8 @@ the crontabs on servers with one or more of the roles in that list.
 Jobs with no :roles argument will be deployed to all servers in the whenever_roles
 list. This is to maintain backward compatibility with previous releases of whenever.
 
-So, for example, with the default whenever_roles of [:db], a job like this would be
-deployed to all servers with the :db role:
+So, for example, with the default whenever_roles of `[:db]`, a job like this would be
+deployed to all servers with the `:db` role:
 
 ```ruby
 every :day, :at => '12:20am' do
@@ -174,7 +258,7 @@ every :day, :at => '12:20am' do
 end
 ```
 
-If we set whenever_roles to [:db, :app] in deploy.rb, and have the following
+If we set whenever_roles to `[:db, :app]` in deploy.rb, and have the following
 jobs in schedule.rb:
 
 ```ruby
@@ -209,14 +293,13 @@ If your production environment uses RVM (Ruby Version Manager) you will run into
 
 This tells rvm to trust all rvmrc files.
 
-### The `whenever` command
+### Heroku?
 
-```sh
-$ cd /apps/my-great-project
-$ whenever
-```
+No. Heroku does not support cron, instead providing [Heroku Scheduler](https://devcenter.heroku.com/articles/scheduler). If you deploy to Heroku, you should use that rather than Whenever.
+
+### Testing
 
-This will simply show you your `schedule.rb` file converted to cron syntax. It does not read or write your crontab file. Run `whenever --help` for a complete list of options.
+[whenever-test](https://github.com/heartbits/whenever-test) is an extension to Whenever for testing a Whenever schedule.
 
 ### Credit
 
@@ -235,8 +318,8 @@ It's a little bit dated now, but remains a good introduction.
 
 ----
 
-Compatible with Ruby 1.8.7-2.1.0, JRuby, and Rubinius. [![Build Status](https://secure.travis-ci.org/javan/whenever.png)](http://travis-ci.org/javan/whenever)
+[![Build Status](https://secure.travis-ci.org/javan/whenever.png)](http://travis-ci.org/javan/whenever)
 
 ----
 
-Copyright &copy; 2014 Javan Makhmali
+Copyright &copy; 2017 Javan Makhmali

data/Rakefile

@@ -1,17 +1,10 @@
-begin
-  require 'bundler'
-rescue LoadError => e
-  warn("warning: Could not load bundler: #{e}")
-  warn("         Some rake tasks will not be defined")
-else
-  Bundler::GemHelper.install_tasks
-end
-
+require 'bundler/gem_tasks'
 require 'rake/testtask'
+
 Rake::TestTask.new(:test) do |test|
   test.libs      << 'lib' << 'test'
   test.pattern   = 'test/{functional,unit}/**/*_test.rb'
   test.verbose   = true
 end
 
-task :default => :test
+task :default => :test

data/bin/whenever

@@ -35,6 +35,9 @@ OptionParser.new do |opts|
   opts.on('-r', '--roles [role1,role2]', 'Comma-separated list of server roles to generate cron jobs for') do |roles|
     options[:roles] = roles.split(',').map(&:to_sym) if roles
   end
+  opts.on('-x', '--crontab-command [command]', 'Default: crontab') do |crontab_command|
+    options[:crontab_command] = crontab_command if crontab_command
+  end
   opts.on('-v', '--version') { puts "Whenever v#{Whenever::VERSION}"; exit(0) }
 end.parse!
 

data/bin/wheneverize

@@ -18,7 +18,7 @@ OptionParser.new do |opts|
 end
 
 unless ARGV.empty?
-  if !File.exists?(ARGV.first)
+  if !File.exist?(ARGV.first)
     abort "`#{ARGV.first}' does not exist."
   elsif !File.directory?(ARGV.first)
     abort "`#{ARGV.first}' is not a directory."
@@ -54,13 +54,16 @@ file = 'config/schedule.rb'
 base = ARGV.empty? ? '.' : ARGV.shift
 
 file = File.join(base, file)
-if File.exists?(file)
+if File.exist?(file)
   warn "[skip] `#{file}' already exists"
-elsif File.exists?(file.downcase)
+elsif File.exist?(file.downcase)
   warn "[skip] `#{file.downcase}' exists, which could conflict with `#{file}'"
-elsif !File.exists?(File.dirname(file))
-  warn "[skip] directory `#{File.dirname(file)}' does not exist"
 else
+  dir = File.dirname(file)
+  if !File.exist?(dir)
+    warn "[add] creating `#{dir}'"
+    FileUtils.mkdir_p(dir)
+  end
   puts "[add] writing `#{file}'"
   File.open(file, "w") { |f| f.write(content) }
 end

data/gemfiles/activesupport4.1.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.1.0"
+
+gemspec path: "../"

data/gemfiles/activesupport4.2.gemfile

@@ -0,0 +1,5 @@
+source "https://rubygems.org"
+
+gem "activesupport", "~> 4.2.0"
+
+gemspec path: "../"

data/lib/whenever/capistrano/v2/recipes.rb

@@ -7,10 +7,11 @@ Capistrano::Configuration.instance(:must_exist).load do
   _cset(:whenever_options)      { {:roles => fetch(:whenever_roles)} }
   _cset(:whenever_command)      { "whenever" }
   _cset(:whenever_identifier)   { fetch :application }
-  _cset(:whenever_environment)  { fetch :rails_env, "production" }
+  _cset(:whenever_environment)  { fetch :rails_env, fetch(:stage, "production") }
   _cset(:whenever_variables)    { "environment=#{fetch :whenever_environment}" }
   _cset(:whenever_update_flags) { "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
   _cset(:whenever_clear_flags)  { "--clear-crontab #{fetch :whenever_identifier}" }
+  _cset(:whenever_path)         { fetch :latest_release }
 
   namespace :whenever do
     desc "Update application's crontab entries using Whenever"
@@ -18,7 +19,7 @@ Capistrano::Configuration.instance(:must_exist).load do
       args = {
         :command => fetch(:whenever_command),
         :flags   => fetch(:whenever_update_flags),
-        :path    => fetch(:latest_release)
+        :path    => fetch(:whenever_path)
       }
 
       if whenever_servers.any?
@@ -38,7 +39,7 @@ Capistrano::Configuration.instance(:must_exist).load do
         args = {
           :command => fetch(:whenever_command),
           :flags   => fetch(:whenever_clear_flags),
-          :path    => fetch(:latest_release)
+          :path    => fetch(:whenever_path)
         }
 
         whenever_run_commands(args)

data/lib/whenever/capistrano/v3/tasks/whenever.rake

@@ -3,26 +3,37 @@ namespace :whenever do
     args = Array(fetch(:whenever_command)) + args
 
     on roles fetch(:whenever_roles) do |host|
-      host_args = Array(yield(host))
-      within release_path do
+      args_for_host = block_given? ? args + Array(yield(host)) : args
+      within fetch(:whenever_path) do
         with fetch(:whenever_command_environment_variables) do
-          execute *(args + host_args)
+          execute(*args_for_host)
         end
       end
     end
   end
 
+  def load_file
+    file = fetch(:whenever_load_file)
+    if file
+      "-f #{file}"
+    else
+      ''
+    end
+  end
+
   desc "Update application's crontab entries using Whenever"
   task :update_crontab do
     setup_whenever_task do |host|
       roles = host.roles_array.join(",")
-      [fetch(:whenever_update_flags),  "--roles=#{roles}"]
+      [fetch(:whenever_update_flags), "--roles=#{roles}", load_file]
     end
   end
 
   desc "Clear application's crontab entries using Whenever"
   task :clear_crontab do
-    setup_whenever_task(fetch(:whenever_clear_flags))
+    setup_whenever_task do |host|
+      [fetch(:whenever_clear_flags), load_file]
+    end
   end
 
   after "deploy:updated",  "whenever:update_crontab"
@@ -33,11 +44,13 @@ namespace :load do
   task :defaults do
     set :whenever_roles,        ->{ :db }
     set :whenever_command,      ->{ [:bundle, :exec, :whenever] }
-    set :whenever_command_environment_variables, ->{ {} }
+    set :whenever_command_environment_variables, ->{ fetch(:default_env).merge!(rails_env: fetch(:whenever_environment)) }
     set :whenever_identifier,   ->{ fetch :application }
-    set :whenever_environment,  ->{ fetch :rails_env, "production" }
+    set :whenever_environment,  ->{ fetch :rails_env, fetch(:stage, "production") }
     set :whenever_variables,    ->{ "environment=#{fetch :whenever_environment}" }
+    set :whenever_load_file,    ->{ nil }
     set :whenever_update_flags, ->{ "--update-crontab #{fetch :whenever_identifier} --set #{fetch :whenever_variables}" }
     set :whenever_clear_flags,  ->{ "--clear-crontab #{fetch :whenever_identifier}" }
+    set :whenever_path,         ->{ fetch :release_path }
   end
 end

data/lib/whenever/capistrano.rb

@@ -1,7 +1,7 @@
 require 'capistrano/version'
 
 if defined?(Capistrano::VERSION) && Gem::Version.new(Capistrano::VERSION).release >= Gem::Version.new('3.0.0')
-  load File.expand_path("../tasks/whenever.rake", __FILE__)
+  load File.expand_path("../capistrano/v3/tasks/whenever.rake", __FILE__)
 else
   require 'whenever/capistrano/v2/hooks'
 end

data/lib/whenever/command_line.rb

@@ -1,5 +1,4 @@
 require 'fileutils'
-require 'tempfile'
 
 module Whenever
   class CommandLine
@@ -10,11 +9,12 @@ module Whenever
     def initialize(options={})
       @options = options
 
-      @options[:file]       ||= 'config/schedule.rb'
-      @options[:cut]        ||= 0
-      @options[:identifier] ||= default_identifier
+      @options[:crontab_command] ||= 'crontab'
+      @options[:file]            ||= 'config/schedule.rb'
+      @options[:cut]             ||= 0
+      @options[:identifier]      ||= default_identifier
 
-      if !File.exists?(@options[:file]) && @options[:clear].nil?
+      if !File.exist?(@options[:file]) && @options[:clear].nil?
         warn("[fail] Can't find file: #{@options[:file]}")
         exit(1)
       end
@@ -29,6 +29,8 @@ module Whenever
         exit(1)
       end
       @options[:cut] = @options[:cut].to_i
+
+      @timestamp = Time.now.to_s
     end
 
     def run
@@ -56,9 +58,10 @@ module Whenever
     end
 
     def read_crontab
-      return @current_crontab if @current_crontab
+      return @current_crontab if instance_variable_defined?(:@current_crontab)
 
-      command = ['crontab -l']
+      command = [@options[:crontab_command]]
+      command << '-l'
       command << "-u #{@options[:user]}" if @options[:user]
 
       command_results  = %x[#{command.join(' ')} 2> /dev/null]
@@ -66,42 +69,44 @@ module Whenever
     end
 
     def write_crontab(contents)
-      tmp_cron_file = Tempfile.open('whenever_tmp_cron')
-      tmp_cron_file << contents
-      tmp_cron_file.fsync
-
-      command = ['crontab']
+      command = [@options[:crontab_command]]
       command << "-u #{@options[:user]}" if @options[:user]
-      command << tmp_cron_file.path
+      # Solaris/SmartOS cron does not support the - option to read from stdin.
+      command << "-" unless OS.solaris?
+
+      IO.popen(command.join(' '), 'r+') do |crontab|
+        crontab.write(contents)
+        crontab.close_write
+      end
 
-      if system(command.join(' '))
+      success = $?.exitstatus.zero?
+
+      if success
         action = 'written' if @options[:write]
         action = 'updated' if @options[:update]
         puts "[write] crontab file #{action}"
-        tmp_cron_file.close!
         exit(0)
       else
         warn "[fail] Couldn't write crontab; try running `whenever' with no options to ensure your schedule file is valid."
-        tmp_cron_file.close!
         exit(1)
       end
     end
 
     def updated_crontab
       # Check for unopened or unclosed identifier blocks
-      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close}\s*$")).nil?
-        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open}', but no '#{comment_close}'"
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && (read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")).nil?
+        warn "[fail] Unclosed indentifier; Your crontab file contains '#{comment_open(false)}', but no '#{comment_close(false)}'"
         exit(1)
-      elsif (read_crontab =~ Regexp.new("^#{comment_open}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
-        warn "[fail] Unopened indentifier; Your crontab file contains '#{comment_close}', but no '#{comment_open}'"
+      elsif (read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$")).nil? && read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")
+        warn "[fail] Unopened indentifier; Your crontab file contains '#{comment_close(false)}', but no '#{comment_open(false)}'"
         exit(1)
       end
 
       # If an existing identier block is found, replace it with the new cron entries
-      if read_crontab =~ Regexp.new("^#{comment_open}\s*$") && read_crontab =~ Regexp.new("^#{comment_close}\s*$")
+      if read_crontab =~ Regexp.new("^#{comment_open_regex}\s*$") && read_crontab =~ Regexp.new("^#{comment_close_regex}\s*$")
         # If the existing crontab file contains backslashes they get lost going through gsub.
         # .gsub('\\', '\\\\\\') preserves them. Go figure.
-        read_crontab.gsub(Regexp.new("^#{comment_open}\s*$.+^#{comment_close}\s*$", Regexp::MULTILINE), whenever_cron.chomp.gsub('\\', '\\\\\\'))
+        read_crontab.gsub(Regexp.new("^#{comment_open_regex}\s*$.+^#{comment_close_regex}\s*$", Regexp::MULTILINE), whenever_cron.chomp.gsub('\\', '\\\\\\'))
       else # Otherwise, append the new cron entries after any existing ones
         [read_crontab, whenever_cron].join("\n\n")
       end.gsub(/\n{3,}/, "\n\n") # More than two newlines becomes just two.
@@ -119,16 +124,32 @@ module Whenever
       stripped_contents.gsub!(/\s+$/, $/)
     end
 
-    def comment_base
-      "Whenever generated tasks for: #{@options[:identifier]}"
+    def comment_base(include_timestamp = true)
+      if include_timestamp
+        "Whenever generated tasks for: #{@options[:identifier]} at: #{@timestamp}"
+      else
+        "Whenever generated tasks for: #{@options[:identifier]}"
+      end
+    end
+
+    def comment_open(include_timestamp = true)
+      "# Begin #{comment_base(include_timestamp)}"
+    end
+
+    def comment_close(include_timestamp = true)
+      "# End #{comment_base(include_timestamp)}"
+    end
+
+    def comment_open_regex
+      "#{comment_open(false)}(#{timestamp_regex}|)"
     end
 
-    def comment_open
-      "# Begin #{comment_base}"
+    def comment_close_regex
+      "#{comment_close(false)}(#{timestamp_regex}|)"
     end
 
-    def comment_close
-      "# End #{comment_base}"
+    def timestamp_regex
+      " at: \\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2} ([+-]\\d{4}|UTC)"
     end
   end
 end