rufus-scheduler 3.7.0 → 3.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c0572c41e8ad285c2de6828cc86ef489122cea65c412514566c08c35713a0523
-  data.tar.gz: 327a0c5e462acc3df68d6c55366a956c9e16b4b4adf208b103568cce4f943dd6
+  metadata.gz: 9fbe0f73068129b96196031b141f480f830e3110e35d3c5eaa2206530b1ae536
+  data.tar.gz: bec310a43820928b8d342b5b3602edf8cb27aaca8995e0a18073d70dfd3839f8
 SHA512:
-  metadata.gz: e3153aa15933ee24cf3a11657fb0b8bd3d58d87e054b20d9d759b52cdd924a418fcf95ef1e14b980b459a501ccce91b285cd85c826e0fa4207fac85f69c77667
-  data.tar.gz: e7af296c9864ffc392ef44eec1bb6ed0331065658b9d9d1225cd2c1f62d1d67302db7075540b0c39a99dcf5f741471f3c38666cb8870165cca23a34f52f1c7df
+  metadata.gz: 3e8edfd4df2ddbb0f8026ffa13fff69f9f4bd045da1638fe5ac38610992e0f7d173b20a27ad1833760d6fee62d41b5b160978e107dbc55a1b9d07dfaa62444ad
+  data.tar.gz: 412bb7e80546c5cd13bf8875f928ce6920a9e62774d296db83935adbfee56069cbb2729bb4640962351297cd55b8b5cfb92facfec38e7cb92b3ef9f7446c7283

data/CHANGELOG.md

@@ -2,6 +2,23 @@
 # CHANGELOG.md
 
 
+### rufus-scheduler 3.8.2 - released 2022-07-12
+
+* Prevent error in shutdown when @thread is current Thread, gh-337
+* Rescue errors on the scheduling thread, gh-335
+
+
+### rufus-scheduler 3.8.1 - released 2022-01-11
+
+* Suppress warning about @resume_discard_past
+* Suppress warning about unused variable, solackerman gh-332
+
+
+### rufus-scheduler 3.8.0 - released 2021-07-14
+
+* Add #source_location to Job, gh-322
+
+
 ### rufus-scheduler 3.7.0 - released 2020-12-31
 
 * Implement Job name:/n: #name and #name=, gh-309

data/CREDITS.md

@@ -4,7 +4,12 @@
 
 ## Contributors
 
-* John Bachir https://github.com/jjb gh-310
+* Bence Monus https://github.com/cromega gh-337 on_error and friends
+* Talia Wong https://github.com/blowfishpro gh-335 on_error and friends
+* Konstantin https://github.com/fa11enangel gh-334 nodejitsu link
+* Olle Jonsson https://github.com/olleolleolle gh-333
+* Sol Ackerman https://github.com/solarckerman gh-332
+* John Bachir https://github.com/jjb gh-310 gh-327
 * Daniel Berger https://github.com/djberg96 gh-300
 * Ceyhun Onur https://github.com/ceyonur parse_cron no_error: true
 * Darwin Wu https://github.com/dwaxe Rails initializer vs tests change

data/LICENSE.txt

@@ -1,5 +1,5 @@
 
-Copyright (c) 2005-2020, John Mettraux, jmettraux@gmail.com
+Copyright (c) 2005-2022, John Mettraux, jmettraux@gmail.com
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

data/README.md

@@ -1,7 +1,7 @@
 
 # rufus-scheduler
 
-[![Build Status](https://secure.travis-ci.org/jmettraux/rufus-scheduler.svg)](https://travis-ci.org/jmettraux/rufus-scheduler)
+[![tests](https://github.com/jmettraux/rufus-scheduler/workflows/test/badge.svg)](https://github.com/jmettraux/rufus-scheduler/actions)
 [![Gem Version](https://badge.fury.io/rb/rufus-scheduler.svg)](https://badge.fury.io/rb/rufus-scheduler)
 [![Join the chat at https://gitter.im/floraison/fugit](https://badges.gitter.im/floraison/fugit.svg)](https://gitter.im/floraison/fugit?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
@@ -133,7 +133,7 @@ Yes, issues can be reported in [rufus-scheduler issues](https://github.com/jmett
 ### faq
 
 * [It doesn't work...](https://www.chiark.greenend.org.uk/~sgtatham/bugs.html)
-* [I want a refund](https://blog.nodejitsu.com/getting-refunds-on-open-source-projects)
+* [I want a refund](https://web.archive.org/web/20160425034214/http://blog.nodejitsu.com/getting-refunds-on-open-source-projects/)
 * [Passenger and rufus-scheduler](https://stackoverflow.com/questions/18108719/debugging-rufus-scheduler/18156180#18156180)
 * [Passenger and rufus-scheduler (2)](https://stackoverflow.com/questions/21861387/rufus-cron-job-not-working-in-apache-passenger#answer-21868555)
 * [Passenger in-depth spawn methods](https://www.phusionpassenger.com/library/indepth/ruby/spawn_methods/)
@@ -223,7 +223,7 @@ job =
 # also
 
 job =
-  scheduler.in '10d', :job => true do
+  scheduler.in '10d', job: true do
     # ...
   end
 ```
@@ -378,7 +378,7 @@ While paused, the scheduler still accepts schedules, but no schedule will get tr
 
 ## job options
 
-### :name => string
+### name: string
 
 Sets the name of the job.
 
@@ -395,23 +395,23 @@ job1 =
 job1.name = 'Beowulf'
 ```
 
-### :blocking => true
+### blocking: true
 
-By default, jobs are triggered in their own, new threads. When `:blocking => true`, the job is triggered in the scheduler thread (a new thread is not created). Yes, while a blocking job is running, the scheduler is not scheduling.
+By default, jobs are triggered in their own, new threads. When `blocking: true`, the job is triggered in the scheduler thread (a new thread is not created). Yes, while a blocking job is running, the scheduler is not scheduling.
 
-### :overlap => false
+### overlap: false
 
 Since, by default, jobs are triggered in their own new threads, job instances might overlap. For example, a job that takes 10 minutes and is scheduled every 7 minutes will have overlaps.
 
-To prevent overlap, one can set `:overlap => false`. Such a job will not trigger if one of its instances is already running.
+To prevent overlap, one can set `overlap: false`. Such a job will not trigger if one of its instances is already running.
 
 The `:overlap` option is considered before the `:mutex` option when the scheduler is reviewing jobs for triggering.
 
-### :mutex => mutex_instance / mutex_name / array of mutexes
+### mutex: mutex_instance / mutex_name / array of mutexes
 
 When a job with a mutex triggers, the job's block is executed with the mutex around it, preventing other jobs with the same mutex from entering (it makes the other jobs wait until it exits the mutex).
 
-This is different from `:overlap => false`, which is, first, limited to instances of the same job, and, second, doesn't make the incoming job instance block/wait but give up.
+This is different from `overlap: false`, which is, first, limited to instances of the same job, and, second, doesn't make the incoming job instance block/wait but give up.
 
 `:mutex` accepts a mutex instance or a mutex name (String). It also accept an array of mutex names / mutex instances. It allows for complex relations between jobs.
 
@@ -421,12 +421,12 @@ Note: creating lots of different mutexes is OK. Rufus-scheduler will place them
 
 The `:overlap` option is considered before the `:mutex` option when the scheduler is reviewing jobs for triggering.
 
-### :timeout => duration or point in time
+### timeout: duration or point in time
 
 It's OK to specify a timeout when scheduling some work. After the time specified, it gets interrupted via a Rufus::Scheduler::TimeoutError.
 
 ```ruby
-scheduler.in '10d', :timeout => '1d' do
+scheduler.in '10d', timeout: '1d' do
   begin
     # ... do something
   rescue Rufus::Scheduler::TimeoutError
@@ -447,15 +447,15 @@ In the case of an "every" job, this will be the first time (modulo the scheduler
 For a "cron" job as well, the :first will point to the first time the job has to trigger, the following trigger times are then determined by the cron string.
 
 ```ruby
-scheduler.every '2d', :first_at => Time.now + 10 * 3600 do
+scheduler.every '2d', first_at: Time.now + 10 * 3600 do
   # ... every two days, but start in 10 hours
 end
 
-scheduler.every '2d', :first_in => '10h' do
+scheduler.every '2d', first_in: '10h' do
   # ... every two days, but start in 10 hours
 end
 
-scheduler.cron '00 14 * * *', :first_in => '3d' do
+scheduler.cron '00 14 * * *', first_in: '3d' do
   # ... every day at 14h00, but start after 3 * 24 hours
 end
 ```
@@ -477,7 +477,7 @@ s = Rufus::Scheduler.new
 
 n = Time.now; p [ :scheduled_at, n, n.to_f ]
 
-s.every '3s', :first => :now do
+s.every '3s', first: :now do
   n = Time.now; p [ :in, n, n.to_f ]
 end
 
@@ -502,15 +502,15 @@ This option is for repeat jobs (cron / every) only.
 It indicates the point in time after which the job should unschedule itself.
 
 ```ruby
-scheduler.cron '5 23 * * *', :last_in => '10d' do
+scheduler.cron '5 23 * * *', last_in: '10d' do
   # ... do something every evening at 23:05 for 10 days
 end
 
-scheduler.every '10m', :last_at => Time.now + 10 * 3600 do
+scheduler.every '10m', last_at: Time.now + 10 * 3600 do
   # ... do something every 10 minutes for 10 hours
 end
 
-scheduler.every '10m', :last_in => 10 * 3600 do
+scheduler.every '10m', last_in: 10 * 3600 do
   # ... do something every 10 minutes for 10 hours
 end
 ```
@@ -525,16 +525,16 @@ job.last_at = Rufus::Scheduler.parse('2029-12-12')
   # set the last bound
 ```
 
-### :times => nb of times (before auto-unscheduling)
+### times: nb of times (before auto-unscheduling)
 
 One can tell how many times a repeat job (CronJob or EveryJob) is to execute before unscheduling by itself.
 
 ```ruby
-scheduler.every '2d', :times => 10 do
+scheduler.every '2d', times: 10 do
   # ... do something every two days, but not more than 10 times
 end
 
-scheduler.cron '0 23 * * *', :times => 31 do
+scheduler.cron '0 23 * * *', times: 31 do
   # ... do something every day at 23:00 but do it no more than 31 times
 end
 ```
@@ -542,7 +542,7 @@ end
 It's OK to assign nil to :times to make sure the repeat job is not limited. It's useful when the :times is determined at scheduling time.
 
 ```ruby
-scheduler.cron '0 23 * * *', :times => nolimit ? nil : 10 do
+scheduler.cron '0 23 * * *', times: (nolimit ? nil : 10) do
   # ...
 end
 ```
@@ -564,7 +564,7 @@ job.times = 10
 
 ## Job methods
 
-When calling a schedule method, the id (String) of the job is returned. Longer schedule methods return Job instances directly. Calling the shorter schedule methods with the :job => true also returns Job instances instead of Job ids (Strings).
+When calling a schedule method, the id (String) of the job is returned. Longer schedule methods return Job instances directly. Calling the shorter schedule methods with the `job: true` also returns Job instances instead of Job ids (Strings).
 
 ```ruby
   require 'rufus-scheduler'
@@ -582,7 +582,7 @@ When calling a schedule method, the id (String) of the job is returned. Longer s
     end
 
   job =
-    scheduler.in '1w', :job => true do
+    scheduler.in '1w', job: true do
       # ...
     end
 ```
@@ -608,7 +608,7 @@ Returns the scheduler instance itself.
 Returns the options passed at the Job creation.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.opts
   # => { :tag => 'hello' }
 ```
@@ -618,7 +618,7 @@ job.opts
 Returns the original schedule.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.original
   # => '10d'
 ```
@@ -665,12 +665,30 @@ job.callable
   # => #<MyHandler:0x0000000163ae88 @counter=0>
 ```
 
+### source_location
+
+Added to rufus-scheduler 3.8.0.
+
+Returns the array `[ 'path/to/file.rb', 123 ]` like `Proc#source_location` does.
+
+```ruby
+require 'rufus-scheduler'
+
+scheduler = Rufus::Scheduler.new
+
+job = scheduler.schedule_every('2h') { p Time.now }
+
+p job.source_location
+  # ==> [ '/home/jmettraux/rufus-scheduler/test.rb', 6 ]
+
+```
+
 ### scheduled_at
 
 Returns the Time instance when the job got created.
 
 ```ruby
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.scheduled_at
   # => 2013-07-17 23:48:54 +0900
 ```
@@ -773,7 +791,7 @@ job = scheduler.schedule_in('10d') do; end
 job.tags
   # => []
 
-job = scheduler.schedule_in('10d', :tag => 'hello') do; end
+job = scheduler.schedule_in('10d', tag: 'hello') do; end
 job.tags
   # => [ 'hello' ]
 ```
@@ -842,7 +860,11 @@ require 'rufus-scheduler'
 s = Rufus::Scheduler.new
 
 def s.on_error(job, err)
-  p [ 'error in scheduled job', job.class, job.original, err.message ]
+  if job
+    p [ 'error in scheduled job', job.class, job.original, err.message ]
+  else
+    p [ 'error while scheduling', err.message ]
+  end
 rescue
   p $!
 end
@@ -958,24 +980,24 @@ Here is an example:
   scheduler.at_jobs.each(&:unschedule)
 ```
 
-### Scheduler#jobs(:tag / :tags => x)
+### Scheduler#jobs(tag: / tags: x)
 
 When scheduling a job, one can specify one or more tags attached to the job. These can be used to look up the job later on.
 
 ```ruby
-  scheduler.in '10d', :tag => 'main_process' do
+  scheduler.in '10d', tag: 'main_process' do
     # ...
   end
-  scheduler.in '10d', :tags => [ 'main_process', 'side_dish' ] do
+  scheduler.in '10d', tags: [ 'main_process', 'side_dish' ] do
     # ...
   end
 
   # ...
 
-  jobs = scheduler.jobs(:tag => 'main_process')
+  jobs = scheduler.jobs(tag: 'main_process')
     # find all the jobs with the 'main_process' tag
 
-  jobs = scheduler.jobs(:tags => [ 'main_process', 'side_dish' ]
+  jobs = scheduler.jobs(tags: [ 'main_process', 'side_dish' ]
     # find all the jobs with the 'main_process' AND 'side_dish' tags
 ```
 
@@ -1040,7 +1062,7 @@ Lists the work threads associated with the scheduler. The query option defaults
 * :active : all the work threads currently running a Job
 * :vacant : all the work threads currently not running a Job
 
-Note that the main schedule thread will be returned if it is currently running a Job (ie one of those :blocking => true jobs).
+Note that the main schedule thread will be returned if it is currently running a Job (ie one of those `blocking: true` jobs).
 
 ### Scheduler#scheduled?(job_or_job_id)
 
@@ -1048,7 +1070,7 @@ Returns true if the arg is a currently scheduled job (see Job#scheduled?).
 
 ### Scheduler#occurrences(time0, time1)
 
-Returns a hash ```{ job => [ t0, t1, ... ] }``` mapping jobs to their potential trigger time within the ```[ time0, time1 ]``` span.
+Returns a hash `{ job => [ t0, t1, ... ] }` mapping jobs to their potential trigger time within the `[ time0, time1 ]` span.
 
 Please note that, for interval jobs, the ```#mean_work_time``` is used, so the result is only a prediction.
 
@@ -1205,23 +1227,23 @@ By default, rufus-scheduler sleeps 0.300 second between every step. At each step
 The :frequency option lets you change that 0.300 second to something else.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:frequency => 5)
+scheduler = Rufus::Scheduler.new(frequency: 5)
 ```
 
 It's OK to use a time string to specify the frequency.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:frequency => '2h10m')
+scheduler = Rufus::Scheduler.new(frequency: '2h10m')
   # this scheduler will sleep 2 hours and 10 minutes between every "step"
 ```
 
 Use with care.
 
-### :lockfile => "mylockfile.txt"
+### lockfile: "mylockfile.txt"
 
 This feature only works on OSes that support the flock (man 2 flock) call.
 
-Starting the scheduler with ```:lockfile => ".rufus-scheduler.lock"``` will make the scheduler attempt to create and lock the file ```.rufus-scheduler.lock``` in the current working directory. If that fails, the scheduler will not start.
+Starting the scheduler with ```lockfile: '.rufus-scheduler.lock'``` will make the scheduler attempt to create and lock the file ```.rufus-scheduler.lock``` in the current working directory. If that fails, the scheduler will not start.
 
 The idea is to guarantee only one scheduler (in a group of schedulers sharing the same lockfile) is running.
 
@@ -1250,7 +1272,7 @@ class HostLock
 end
 
 scheduler =
-  Rufus::Scheduler.new(:scheduler_lock => HostLock.new('coffee.example.com'))
+  Rufus::Scheduler.new(scheduler_lock: HostLock.new('coffee.example.com'))
 ```
 
 By default, the scheduler_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that returns true.
@@ -1273,7 +1295,7 @@ class PingLock
 end
 
 scheduler =
-  Rufus::Scheduler.new(:trigger_lock => PingLock.new('main.example.com'))
+  Rufus::Scheduler.new(trigger_lock: PingLock.new('main.example.com'))
 ```
 
 By default, the trigger_lock is an instance of `Rufus::Scheduler::NullLock`, with a `#lock` that always returns true.
@@ -1287,7 +1309,7 @@ In rufus-scheduler 2.x, by default, each job triggering received its own, brand
 One can set this maximum value when starting the scheduler.
 
 ```ruby
-scheduler = Rufus::Scheduler.new(:max_work_threads => 77)
+scheduler = Rufus::Scheduler.new(max_work_threads: 77)
 ```
 
 It's OK to increase the :max_work_threads of a running scheduler.
@@ -1309,8 +1331,8 @@ Rufus::Scheduler.singleton.every '10s' { puts "hello, world!" }
 It's OK to pass initialization arguments (like :frequency or :max_work_threads) but they will only be taken into account the first time ```.singleton``` is called.
 
 ```ruby
-Rufus::Scheduler.singleton(:max_work_threads => 77)
-Rufus::Scheduler.singleton(:max_work_threads => 277) # no effect
+Rufus::Scheduler.singleton(max_work_threads: 77)
+Rufus::Scheduler.singleton(max_work_threads: 277) # no effect
 ```
 
 The ```.s``` is a shortcut for ```.singleton```.
@@ -1427,7 +1449,7 @@ Rufus::Scheduler.to_duration_hash(60)
 Rufus::Scheduler.to_duration_hash(62.127)
   # => { :m => 1, :s => 2, :ms => 127 }
 
-Rufus::Scheduler.to_duration_hash(62.127, :drop_seconds => true)
+Rufus::Scheduler.to_duration_hash(62.127, drop_seconds: true)
   # => { :m => 1 }
 ```
 
@@ -1610,7 +1632,7 @@ class ScheController < ApplicationController
         Rails.logger.info "time flies, it's now #{Time.now}"
       end
 
-    render :text => "scheduled job #{job_id}"
+    render text: "scheduled job #{job_id}"
   end
 end
 ```
@@ -1631,14 +1653,16 @@ If you don't want rufus-scheduler to trigger anything while running the Ruby on
 
 require 'rufus-scheduler'
 
-s = Rufus::Scheduler.singleton
+return if defined?(Rails::Console) || Rails.env.test? || File.split($PROGRAM_NAME).last == 'rake'
+  #
+  # do not schedule when Rails is run from its console, for a test/spec, or
+  # from a Rake task
 
-return if defined?(Rails::Console) || Rails.env.test? || File.split($0).last == 'rake'
 # return if $PROGRAM_NAME.include?('spring')
+  #
   # see https://github.com/jmettraux/rufus-scheduler/issues/186
 
-# do not schedule when Rails is run from its console, for a test/spec, or
-# from a Rake task
+s = Rufus::Scheduler.singleton
 
 s.every '1m' do
   Rails.logger.info "hello, it's #{Time.now}"
@@ -1646,6 +1670,8 @@ s.every '1m' do
 end
 ```
 
+(Beware later version of Rails where Spring takes care pre-running the initializers. Running `spring stop` or disabling Spring might be necessary in some cases to see changes to initializers being taken into account.)
+
 
 ### rails server -d
 
@@ -1662,6 +1688,9 @@ These are two well crafted articles on process daemonization, please read them:
 
 If, anyway, you need something like `rails server -d`, why not try `bundle exec unicorn -D` instead? In my (limited) experience, it worked out of the box (well, had to add `gem 'unicorn'` to `Gemfile` first).
 
+### executor / reloader
+
+You might benefit from wraping your scheduled code in the executor or reloader. Read more here: https://guides.rubyonrails.org/threading_and_code_execution.html
 
 ## support
 

data/lib/rufus/scheduler/jobs_core.rb

@@ -97,6 +97,12 @@ class Rufus::Scheduler::Job
 
   alias job_id id
 
+  def source_location
+
+    @callable.source_location
+  end
+  alias location source_location
+
   # Will fail with an ArgumentError if the job frequency is higher than
   # the scheduler frequency.
   #

data/lib/rufus/scheduler/jobs_repeat.rb

@@ -25,6 +25,8 @@ class Rufus::Scheduler::RepeatJob < Rufus::Scheduler::Job
       nil
     self.last_at =
       opts[:last] || opts[:last_at] || opts[:last_in]
+
+    @resume_discard_past = nil
   end
 
   FIRSTS = [ :now, :immediately, 0 ].freeze

data/lib/rufus/scheduler.rb

@@ -9,7 +9,7 @@ module Rufus; end
 
 class Rufus::Scheduler
 
-  VERSION = '3.7.0'
+  VERSION = '3.8.2'
 
   EoTime = ::EtOrbi::EoTime
 
@@ -443,9 +443,14 @@ class Rufus::Scheduler
     ms = {}; mutexes.each { |k, v| ms[k] = v.locked? }
 
     stderr.puts("{ #{pre} rufus-scheduler intercepted an error:")
-    stderr.puts("  #{pre}   job:")
-    stderr.puts("  #{pre}     #{job.class} #{job.original.inspect} #{job.opts.inspect}")
-    # TODO: eventually use a Job#detail or something like that
+    if job
+      stderr.puts("  #{pre}   job:")
+      stderr.puts("  #{pre}     #{job.class} #{job.original.inspect} #{job.opts.inspect}")
+      stderr.puts("  #{pre}     #{job.source_location.inspect}")
+      # TODO: eventually use a Job#detail or something like that
+    else
+      stderr.puts("  #{pre}   job: (error did not occur in a job)")
+    end
     stderr.puts("  #{pre}   error:")
     stderr.puts("  #{pre}     #{err.object_id}")
     stderr.puts("  #{pre}     #{err.class}")
@@ -529,7 +534,7 @@ class Rufus::Scheduler
 
     unlock
 
-    @thread.join
+    @thread.join unless @thread == Thread.current
   end
   alias stop shutdown
 
@@ -582,7 +587,7 @@ class Rufus::Scheduler
       r =
         begin
           @join_queue.pop(true)
-        rescue ThreadError => e
+        rescue ThreadError
           # #<ThreadError: queue empty>
           false
         end
@@ -629,12 +634,20 @@ class Rufus::Scheduler
       Thread.new do
 
         while @started_at do
+          begin
+
+            unschedule_jobs
+            trigger_jobs unless @paused_at
+            timeout_jobs
 
-          unschedule_jobs
-          trigger_jobs unless @paused_at
-          timeout_jobs
+            sleep(@frequency)
 
-          sleep(@frequency)
+          rescue => err
+            #
+            # for `blocking: true` jobs mostly
+            #
+            on_error(nil, err)
+          end
         end
 
         rejoin

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rufus-scheduler
 version: !ruby/object:Gem::Version
-  version: 3.7.0
+  version: 3.8.2
 platform: ruby
 authors:
 - John Mettraux
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-12-30 00:00:00.000000000 Z
+date: 2022-07-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: fugit