async-cron 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: bc78136142298dcbefb1b61a9673fc9ee19cdedcc1f7c49bf734efaf652370d4
+  data.tar.gz: 7ec5b0e30337a7299b3c6b1550d86c1cfef1fae9c811cecb21f17328ada74ccc
+SHA512:
+  metadata.gz: 7c29dd28a35937ba33d423d60c541c1e80f54dd12415228853172697da5c58bbebcb8b85ffa959ae0bd28f5aff991900b9bb5628531430d7cc463aced867a950
+  data.tar.gz: 99ddc742c526e655d7afc5ef73199abb3ff32f137ca4277d5a389ec7b8fb724b91be0bc27204256600d86bc47868327070ff4ac91b1b61f826d1147353ca71b1

data/lib/async/cron/environment/scheduler.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative '../service/scheduler'
+require_relative '../scheduler'
+
+module Async
+	module Cron
+		module Environment
+			# Provides an environment for hosting a web application that uses a Falcon server.
+			module Scheduler
+				def name
+					super || "scheduler"
+				end
+				
+				# The service class to use for the proxy.
+				# @returns [Class]
+				def service_class
+					Service::Scheduler
+				end
+				
+				def scheduler
+					Cron::Scheduler.load(self.root)
+				end
+				
+				def container_options
+					{count: 1}
+				end
+			end
+		end
+	end
+end

data/lib/async/cron/period.rb

@@ -0,0 +1,252 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'time'
+
+module Async
+	module Cron
+		class Period
+			# Parse a string into a period.
+			# @parameter string [String | Nil] The string to parse.
+			def self.parse(string)
+				value, divisor = string&.split('/', 2)
+				
+				if divisor
+					divisor = Integer(divisor)
+				else
+					divisor = 1
+				end
+				
+				if value == '*'
+					value = nil
+				elsif value
+					value = value.split(',').map do |part|
+						if part =~ /\A(\d+)-(\d+)\z/
+							Range.new(Integer($1), Integer($2))
+						elsif part =~ /\A(-?\d+)\.\.(-?\d+)\z/
+							Range.new(Integer($1), Integer($2))
+						else
+							Integer(part)
+						end
+					end
+				end
+				
+				self.new(value, divisor)
+			end
+			
+			RANGE = nil
+			
+			def initialize(value = nil, divisor = 1, range: self.class::RANGE)
+				@value = value
+				@divisor = divisor
+				@range = range
+				
+				if @values = divide(expand(@value))
+					# This is an optimization to avoid recalculating the successors every time:
+					@successors = successors(@values)
+				end
+			end
+			
+			def to_a
+				@values
+			end
+			
+			# Increment the specific time unit to the next possible value.
+			# @parameter time [Time] The time to increment, must be normalized.
+			def increment(time)
+				time.seconds = @successors[time.seconds]
+			end
+			
+			def step(time)
+				time = Time.from(time).normalize!
+				
+				increment(time)
+				
+				return time
+			end
+			
+			# Reset the specific time unit to the first value.
+			def reset(time)
+				time.seconds = @values.first
+			end
+			
+			def include?(time)
+				if @values
+					return @values.include?(value_from(time.normalize!))
+				else
+					return true
+				end
+			end
+			
+		private
+			
+			def value_from(time)
+				time.seconds
+			end
+			
+			def expand(values)
+				case values
+				when Array
+					flatten(values)
+				when Range
+					values.to_a
+				when Integer
+					[values]
+				when nil
+					@range&.to_a
+				else
+					raise ArgumentError, "Invalid value: #{values.inspect}"
+				end
+			end
+			
+			def flatten(values)
+				values = values.flat_map do |value|
+					case value
+					when Array
+						flatten(value)
+					when Range
+						value.to_a
+					else
+						value
+					end
+				end
+				
+				values.sort!
+				values.uniq!
+				
+				return values
+			end
+			
+			def divide(values)
+				return values if @divisor == 1 or values.size <= 1
+				raise ArgumentError, "Invalid divisor: #{@divisor}" unless @divisor > 1
+				
+				offset = values.first
+				filtered = {}
+				
+				values.each do |value|
+					key = ((value - offset) / @divisor).floor
+					filtered[key] ||= value
+				end
+				
+				return filtered.values
+			end
+			
+			def successors(values)
+				mapped = @range.to_a
+				
+				current = 0
+				
+				values.each do |value|
+					while current < value
+						mapped[current] = value
+						current += 1
+					end
+				end
+				
+				while current < mapped.size
+					mapped[current] = values.first + mapped.size
+					current += 1
+				end
+				
+				return mapped
+			end
+		end
+		
+		class Seconds < Period
+			RANGE = 0..59
+		end
+		
+		class Minutes < Period
+			RANGE = 0..59
+			
+			def increment(time)
+				time.minutes = @successors[time.minutes]
+			end
+			
+			def reset(time)
+				time.minutes = @values.first
+			end
+			
+			def value_from(time)
+				time.minutes
+			end
+		end
+		
+		class Hours < Period
+			RANGE = 0..23
+			
+			def increment(time)
+				time.hours = @successors[time.hours]
+			end
+			
+			def reset(time)
+				time.hours = @values.first
+			end
+			
+			def value_from(time)
+				time.hours
+			end
+		end
+		
+		class Weekday < Period
+			RANGE = 0..6
+			
+			def increment(time)
+				time.weekday = @successors[time.weekday]
+			end
+			
+			def reset(time)
+				time.weekday = @values.first
+			end
+			
+			def value_from(time)
+				time.weekday
+			end
+		end
+		
+		class Monthday < Period
+			def increment(time)
+				current_time = time.dup
+				monthday = @successors[time.days] || @values.first
+				
+				time.monthday = monthday
+				
+				while time <= current_time
+					time.months += 1
+					time.monthday = monthday
+				end
+			end
+			
+			def reset(time)
+				if @values&.any?
+					time.monthday = @values.first
+				else
+					time.monthday = 0
+				end
+			end
+			
+			def value_from(time)
+				time.days
+			end
+		end
+		
+		class Month < Period
+			RANGE = 0..11
+			
+			def increment(time)
+				time.months = @successors[time.months]
+			end
+			
+			def reset(time)
+				time.months = @values.first
+			end
+			
+			def value_from(time)
+				time.months
+			end
+		end
+	end
+end

data/lib/async/cron/schedule/daily.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'generic'
+require_relative '../period'
+
+module Async
+	module Cron
+		module Schedule
+			# A schedule that runs once per day, at midnight.
+			class Daily < Generic
+				def increment(time = nil)
+					time = Time.from(time) || Time.now
+					
+					time.seconds = 0
+					time.minutes = 0
+					time.hours = 0
+					time.days += 1
+					
+					return time.normalize!
+				end
+			end
+		end
+	end
+end
+

data/lib/async/cron/schedule/flags.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+module Async
+	module Cron
+		module Schedule
+			class Flags
+				def self.parse(string)
+					options = {}
+					
+					string&.each_char do |character|
+						case character
+						when 'D'
+							options[:drop] = true
+						when 'd'
+							options[:drop] = false
+						else
+							raise ArgumentError, "Invalid flag: #{character}"
+						end
+					end
+					
+					self.new(**options)
+				end
+				
+				def initialize(drop: true)
+					@drop = drop
+				end
+				
+				def drop?
+					@drop
+				end
+			end
+		end
+	end
+end

data/lib/async/cron/schedule/generic.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'flags'
+require_relative '../time'
+
+require 'console'
+
+module Async
+	module Cron
+		module Schedule
+			class Generic
+				def initialize(flags = Flags.new)
+					@flags = flags
+				end
+				
+				attr :flags
+				
+				# Compute the next execution time after the given time.
+				def increment(time = nil)
+					Time.now
+				end
+				
+				def run_once(time = Time.now, &block)
+					# The number of times the schedule has been dropped because the scheduled time was in the past:
+					dropped = 0
+					
+					while true
+						# Compute the next scheduled time:
+						scheduled_time = increment(time)
+						
+						# If the time is not advancing and we are dropping, then raise an error:
+						if scheduled_time <= time and dropped > 0
+							raise RuntimeError, "Scheduled time is not advancing: #{scheduled_time} <= #{time}"
+						end
+						
+						# Compute the delta until the next scheduled time:
+						delta = scheduled_time.delta
+						
+						Console.debug(self, "Next scheduled time.", delta: delta, scheduled_time: scheduled_time, block: block)
+						
+						# If the time is in the past, and we are dropping, then skip this schedule and try again:
+						if delta < 0 and @flags.drop?
+							# This would normally occur if the user code took too long to execute, causing the next scheduled time to be in the past.
+							Console.warn(self, "Skipping schedule because it is in the past.", delta: delta, scheduled_time: scheduled_time, block: block, dropped: dropped)
+							dropped += 1
+							next
+						end
+						
+						break
+					end
+					
+					Console.debug(self, "Waiting for next scheduled time.", delta: delta, scheduled_time: scheduled_time, block: block)
+					sleep(delta) if delta > 0
+					
+					begin
+						invoke(scheduled_time, &block)
+					rescue => error
+						Console::Event::Failure.for(error).emit(self, delta: delta, scheduled_time: scheduled_time, block: block)
+					end
+					
+					return time
+				end
+				
+				def run(time = Time.now, &block)
+					while true
+						time = run_once(time, &block)
+					end
+				end
+				
+				def invoke(time, &block)
+					yield(time)
+				end
+			end
+		end
+	end
+end

data/lib/async/cron/schedule/hourly.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'generic'
+require_relative '../period'
+
+module Async
+	module Cron
+		module Schedule
+			# A schedule that runs once per hour, on the hour.
+			class Hourly < Generic
+				def increment(time = nil)
+					time = Time.from(time) || Time.now
+					
+					time.seconds = 0
+					time.minutes = 0
+					time.hours += 1
+					
+					return time.normalize!
+				end
+			end
+		end
+	end
+end
+

data/lib/async/cron/schedule/monthly.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'generic'
+require_relative '../period'
+
+module Async
+	module Cron
+		module Schedule
+			# A schedule that runs once per day, at midnight.
+			class Monthly < Generic
+				def increment(time = nil)
+					time = Time.from(time) || Time.now
+					
+					time.seconds = 0
+					time.minutes = 0
+					time.hours = 0
+					time.days = 0
+					time.months += 1
+					
+					return time.normalize!
+				end
+			end
+		end
+	end
+end
+

data/lib/async/cron/schedule/periodic.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'generic'
+require_relative '../period'
+
+module Async
+	module Cron
+		module Schedule
+			class Periodic < Generic
+				def self.parse(string)
+					parts = string.split(/\s+/)
+					
+					if parts.last =~ /[a-zA-Z]/
+						flags = Flags.parse(parts.pop)
+					else
+						flags = Flags.new
+					end
+					
+					seconds = Seconds.parse(parts[0])
+					minutes = Minutes.parse(parts[1])
+					hours = Hours.parse(parts[2])
+					weekday = Weekday.parse(parts[3])
+					monthday = Monthday.parse(parts[4])
+					month = Month.parse(parts[5])
+					
+					return self.new(seconds, minutes, hours, weekday, monthday, month, flags)
+				end
+				
+				# Create a new schedule with the given parameters.
+				def initialize(seconds, minutes, hours, weekday, monthday, month, flags = Flags.new)
+					super(flags)
+					
+					@seconds = seconds
+					@minutes = minutes
+					@hours = hours
+					@weekday = weekday
+					@monthday = monthday
+					@month = month
+				end
+				
+				# Compute the next execution time after the given time.
+				def increment(time = nil)
+					time = Time.from(time) || Time.now
+					
+					units = [@seconds, @minutes, @hours, @weekday, @monthday, @month]
+					index = 1
+					
+					# Step the smallest unit first:
+					units[0].increment(time)
+					
+					# Now try to fit the rest of the schedule:
+					while index < units.length
+						unit = units[index]
+						
+						# puts "Checking #{unit} at #{index}... -> #{time}"
+						
+						# If the unit is not already at the desired time, increment it:
+						unless unit.include?(time)
+							# puts "Incrementing #{unit} at #{index}..."
+							unit.increment(time)
+							# puts "-> #{time}"
+							
+							# Reset all smaller units:
+							units[0...index].each do |unit|
+								# puts "Resetting #{unit}..."
+								unit.reset(time)
+							end
+						end
+						
+						index += 1
+					end
+					
+					return time.normalize!
+				end
+			end
+		end
+	end
+end
+

data/lib/async/cron/schedule/weekly.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'generic'
+require_relative '../period'
+
+module Async
+	module Cron
+		module Schedule
+			# A schedule that runs once per day, at midnight.
+			class Weekly < Generic
+				def increment(time = nil)
+					time = Time.from(time) || Time.now
+					
+					time.seconds = 0
+					time.minutes = 0
+					time.hours = 0
+					# 0-6, Sunday is zero
+					time.weekday = 7
+					
+					return time.normalize!
+				end
+			end
+		end
+	end
+end
+

data/lib/async/cron/schedule.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+# These are mostly just for convenience:
+require_relative 'schedule/hourly'
+require_relative 'schedule/daily'
+require_relative 'schedule/weekly'
+require_relative 'schedule/monthly'
+
+# This one gives you a lot of flexibility at the expense of being sgightly more verbose:
+require_relative 'schedule/periodic'

data/lib/async/cron/scheduler.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'async'
+require 'async/barrier'
+
+module Async
+	module Cron
+		class Scheduler
+			class Loader
+				def initialize(scheduler)
+					@scheduler = scheduler
+				end
+				
+				def add(schedule, &block)
+					@scheduler.add(schedule, &block)
+				end
+				
+				def hourly(&block)
+					add(Schedule::Hourly.new, &block)
+				end
+				
+				def daily(&block)
+					add(Schedule::Daily.new, &block)
+				end
+				
+				def weekly(&block)
+					add(Schedule::Weekly.new, &block)
+				end
+				
+				def monthly(&block)
+					add(Schedule::Monthly.new, &block)
+				end
+				
+				def periodic(specification, &block)
+					add(Schedule::Periodic.parse(specification), &block)
+				end
+			end
+			
+			PATH = "config/async/cron/scheduler.rb"
+			
+			def self.load(root = Dir.pwd)
+				path = ::File.join(root, PATH)
+				
+				if ::File.exist?(path)
+					return self.load_file(path)
+				end
+			end
+			
+			def self.load_file(path)
+				scheduler = self.new
+				loader = Loader.new(scheduler)
+				
+				loader.instance_eval(::File.read(path), path)
+				
+				return scheduler
+			end
+			
+			def initialize
+				@schedules = Hash.new.compare_by_identity
+			end
+			
+			attr :schedules
+			
+			def add(schedule, &block)
+				@schedules[schedule] = block
+			end
+			
+			def run
+				Sync do
+					barrier = Async::Barrier.new
+					
+					@schedules.each do |schedule, block|
+						barrier.async do
+							schedule.run(&block)
+						end
+					end
+					
+					barrier.wait
+				end
+			end
+		end
+	end
+end

data/lib/async/cron/service/scheduler.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2019-2024, by Samuel Williams.
+# Copyright, 2020, by Daniel Evans.
+
+require 'async/service/generic'
+
+module Async
+	module Cron
+		module Service
+			class Scheduler < Async::Service::Generic
+				# Setup the container with the application instance.
+				# @parameter container [Async::Container::Generic]
+				def setup(container)
+					container_options = @evaluator.container_options
+					
+					container.run(name: self.name, **container_options) do |instance|
+						evaluator = @environment.evaluator
+						
+						Async do |task|
+							scheduler = evaluator.scheduler
+							
+							task = Async do
+								scheduler.run
+							end
+							
+							instance.ready!
+							
+							task.wait
+						end
+					end
+				end
+			end
+		end
+	end
+end

data/lib/async/cron/time.rb

@@ -0,0 +1,162 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require 'date'
+
+module Async
+	module Cron
+		# A base-zero that supports assigning arbitrary values (both positive and negative) to all units. This simplifies computing relative times and dates by incrementing the relevant units and normalizing the result.
+		#
+		# **Note that base-zero means that the month and day start from zero, not one, as is the case with the standard Ruby Time and Date classes.** That is because the fields also accept negative values, which would be ambiguous if the month and day started from one.
+		class Time
+			include Comparable
+			
+			def self.from(time)
+				case time
+				when ::Time
+					return self.new(time.year, time.month-1, time.day-1, time.hour, time.min, time.sec, time.utc_offset)
+				when ::DateTime
+					return self.new(time.year, time.month-1, time.day-1, time.hour, time.min, time.sec, time.offset)
+				when ::Date
+					return self.new(time.year, time.month-1, time.day-1, 0, 0, 0, 0)
+				when self
+					return time.dup
+				end
+			end
+			
+			def self.now
+				return self.from(::Time.now)
+			end
+			
+			# @parameter years [Integer] The number of years.
+			# @parameter months [Integer] The number of months.
+			# @parameter days [Integer] The number of days.
+			# @parameter hours [Integer] The number of hours.
+			# @parameter minutes [Integer] The number of minutes.
+			# @parameter seconds [Integer] The number of seconds.
+			# @parameter offset [Integer] The time zone offset.
+			def initialize(years, months, days, hours, minutes, seconds, offset)
+				@years = years
+				@months = months
+				@days = days
+				@hours = hours
+				@minutes = minutes
+				@seconds = seconds
+				@offset = offset
+			end
+			
+			def freeze
+				return self if frozen?
+				
+				@years.freeze
+				@months.freeze
+				@days.freeze
+				@hours.freeze
+				@minutes.freeze
+				@seconds.freeze
+				@offset.freeze
+				
+				super
+			end
+			
+			attr_accessor :years
+			attr_accessor :months
+			attr_accessor :days
+			
+			attr_accessor :hours
+			attr_accessor :minutes
+			attr_accessor :seconds
+			
+			attr_accessor :offset
+			
+			def weekday
+				to_date.wday
+			end
+			
+			def weekday=(value)
+				@days += value - weekday
+			end
+			
+			def monthday=(value)
+				if value >= 0
+					@days = value
+				else
+					@days = ::Date.new(@years, @months+1, value).day
+				end
+			end
+			
+			def to_a
+				[@years, @months, @days, @hours, @minutes, @seconds, @offset]
+			end
+			
+			def <=> other
+				to_a <=> other.to_a
+			end
+			
+			def hash
+				to_a.hash
+			end
+			
+			def eql? other
+				to_a.eql?(other.to_a)
+			end
+			
+			def delta
+				self.to_time - ::Time.now
+			end
+			
+			def to_time
+				normalized = self.dup.normalize!
+				
+				return ::Time.new(normalized.years, normalized.months+1, normalized.days+1, normalized.hours, normalized.minutes, normalized.seconds, normalized.offset)
+			end
+			
+			def to_datetime
+				normalized = self.dup.normalize!
+				
+				return ::DateTime.new(normalized.years, normalized.months+1, normalized.days+1, normalized.hours, normalized.minutes, normalized.seconds, normalized.offset)
+			end
+			
+			def to_date
+				normalized = self.dup.normalize!
+				
+				return ::Date.new(normalized.years, normalized.months+1, normalized.days+1)
+			end
+			
+			def normalize!
+				seconds = self.seconds
+				delta_minutes = seconds / 60
+				seconds = seconds % 60
+				
+				minutes = self.minutes + delta_minutes
+				delta_hours = minutes / 60
+				minutes = minutes % 60
+				
+				hours = self.hours + delta_hours
+				delta_days = hours / 24
+				hours = hours % 24
+				
+				days = self.days + delta_days
+				months = self.months
+				years = self.years
+				
+				date = (Date.new(years, 1, 1) >> months) + days
+				
+				@years = date.year
+				@months = date.month - 1
+				@days = date.day - 1
+				@hours = hours
+				@minutes = minutes
+				@seconds = seconds
+				
+				return self
+			end
+			
+			def to_s
+				sprintf("%04d+%02d+%02d %02d:%02d:%02d %d", years, months, days, hours, minutes, seconds, offset)
+			end
+		end
+	end
+end

data/lib/async/cron/version.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+module Async
+	module Cron
+		VERSION = '0.1.0'
+	end
+end

data/lib/async/cron.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+# Released under the MIT License.
+# Copyright, 2024, by Samuel Williams.
+
+require_relative 'cron/version'
+require_relative 'cron/schedule'

data/license.md

@@ -0,0 +1,21 @@
+# MIT License
+
+Copyright, 2024, by Samuel Williams.  
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/readme.md

@@ -0,0 +1,23 @@
+# Async::Cron
+
+[![Development Status](https://github.com/socketry/async-cron/workflows/Test/badge.svg)](https://github.com/socketry/async-cron/actions?workflow=Test)
+
+## Usage
+
+## Contributing
+
+We welcome contributions to this project.
+
+1.  Fork it.
+2.  Create your feature branch (`git checkout -b my-new-feature`).
+3.  Commit your changes (`git commit -am 'Add some feature'`).
+4.  Push to the branch (`git push origin my-new-feature`).
+5.  Create new Pull Request.
+
+### Developer Certificate of Origin
+
+This project uses the [Developer Certificate of Origin](https://developercertificate.org/). All contributors to this project must agree to this document to have their contributions accepted.
+
+### Contributor Covenant
+
+This project is governed by the [Contributor Covenant](https://www.contributor-covenant.org/). All contributors and participants agree to abide by its terms.

metadata

@@ -0,0 +1,119 @@
+--- !ruby/object:Gem::Specification
+name: async-cron
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Samuel Williams
+autorequire:
+bindir: bin
+cert_chain:
+- |
+  -----BEGIN CERTIFICATE-----
+  MIIE2DCCA0CgAwIBAgIBATANBgkqhkiG9w0BAQsFADBhMRgwFgYDVQQDDA9zYW11
+  ZWwud2lsbGlhbXMxHTAbBgoJkiaJk/IsZAEZFg1vcmlvbnRyYW5zZmVyMRIwEAYK
+  CZImiZPyLGQBGRYCY28xEjAQBgoJkiaJk/IsZAEZFgJuejAeFw0yMjA4MDYwNDUz
+  MjRaFw0zMjA4MDMwNDUzMjRaMGExGDAWBgNVBAMMD3NhbXVlbC53aWxsaWFtczEd
+  MBsGCgmSJomT8ixkARkWDW9yaW9udHJhbnNmZXIxEjAQBgoJkiaJk/IsZAEZFgJj
+  bzESMBAGCgmSJomT8ixkARkWAm56MIIBojANBgkqhkiG9w0BAQEFAAOCAY8AMIIB
+  igKCAYEAomvSopQXQ24+9DBB6I6jxRI2auu3VVb4nOjmmHq7XWM4u3HL+pni63X2
+  9qZdoq9xt7H+RPbwL28LDpDNflYQXoOhoVhQ37Pjn9YDjl8/4/9xa9+NUpl9XDIW
+  sGkaOY0eqsQm1pEWkHJr3zn/fxoKPZPfaJOglovdxf7dgsHz67Xgd/ka+Wo1YqoE
+  e5AUKRwUuvaUaumAKgPH+4E4oiLXI4T1Ff5Q7xxv6yXvHuYtlMHhYfgNn8iiW8WN
+  XibYXPNP7NtieSQqwR/xM6IRSoyXKuS+ZNGDPUUGk8RoiV/xvVN4LrVm9upSc0ss
+  RZ6qwOQmXCo/lLcDUxJAgG95cPw//sI00tZan75VgsGzSWAOdjQpFM0l4dxvKwHn
+  tUeT3ZsAgt0JnGqNm2Bkz81kG4A2hSyFZTFA8vZGhp+hz+8Q573tAR89y9YJBdYM
+  zp0FM4zwMNEUwgfRzv1tEVVUEXmoFCyhzonUUw4nE4CFu/sE3ffhjKcXcY//qiSW
+  xm4erY3XAgMBAAGjgZowgZcwCQYDVR0TBAIwADALBgNVHQ8EBAMCBLAwHQYDVR0O
+  BBYEFO9t7XWuFf2SKLmuijgqR4sGDlRsMC4GA1UdEQQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MC4GA1UdEgQnMCWBI3NhbXVlbC53aWxs
+  aWFtc0BvcmlvbnRyYW5zZmVyLmNvLm56MA0GCSqGSIb3DQEBCwUAA4IBgQB5sxkE
+  cBsSYwK6fYpM+hA5B5yZY2+L0Z+27jF1pWGgbhPH8/FjjBLVn+VFok3CDpRqwXCl
+  xCO40JEkKdznNy2avOMra6PFiQyOE74kCtv7P+Fdc+FhgqI5lMon6tt9rNeXmnW/
+  c1NaMRdxy999hmRGzUSFjozcCwxpy/LwabxtdXwXgSay4mQ32EDjqR1TixS1+smp
+  8C/NCWgpIfzpHGJsjvmH2wAfKtTTqB9CVKLCWEnCHyCaRVuKkrKjqhYCdmMBqCws
+  JkxfQWC+jBVeG9ZtPhQgZpfhvh+6hMhraUYRQ6XGyvBqEUe+yo6DKIT3MtGE2+CP
+  eX9i9ZWBydWb8/rvmwmX2kkcBbX0hZS1rcR593hGc61JR6lvkGYQ2MYskBveyaxt
+  Q2K9NVun/S785AP05vKkXZEFYxqG6EW012U4oLcFl5MySFajYXRYbuUpH6AY+HP8
+  voD0MPg1DssDLKwXyt1eKD/+Fq0bFWhwVM/1XiAXL7lyYUyOq24KHgQ2Csg=
+  -----END CERTIFICATE-----
+date: 2024-06-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: async
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: async-service
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/async/cron.rb
+- lib/async/cron/environment/scheduler.rb
+- lib/async/cron/period.rb
+- lib/async/cron/schedule.rb
+- lib/async/cron/schedule/daily.rb
+- lib/async/cron/schedule/flags.rb
+- lib/async/cron/schedule/generic.rb
+- lib/async/cron/schedule/hourly.rb
+- lib/async/cron/schedule/monthly.rb
+- lib/async/cron/schedule/periodic.rb
+- lib/async/cron/schedule/weekly.rb
+- lib/async/cron/scheduler.rb
+- lib/async/cron/service/scheduler.rb
+- lib/async/cron/time.rb
+- lib/async/cron/version.rb
+- license.md
+- readme.md
+homepage: https://github.com/socketry/async-cron
+licenses:
+- MIT
+metadata:
+  documentation_uri: https://socketry.github.io/async-cron/
+  funding_uri: https://github.com/sponsors/ioquatix
+  source_code_uri: https://github.com/socketry/async-cron.git
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.5.9
+signing_key:
+specification_version: 4
+summary: A scheduling service using cron-style syntax.
+test_files: []