scheduled 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 688c45f27921579d66859e13503929c9de904061
+  data.tar.gz: cc72fa658f792a10ec443ea1dd79f8ef4e069448
+SHA512:
+  metadata.gz: f254da84808cdaa0d9c1985c52dac01ba120958241d94fcc0c7438d6c6397616b391aa5ec87e70f79242c7643a74c968a49e7e0135fc13081d17c4d3ccf01601
+  data.tar.gz: 61e96fa4874cd744cebd95c21914681511b9567b8b3e8e6d27090655707e83b6e95ab539a266ba2b3ec323d2ee29c7ec7e04064b9daf6a919bc3470a253612f8

data/README.md

@@ -0,0 +1,82 @@
+# Scheduled
+
+A simple task scheduler, akin to ClockWork or Rufus Scheduler.
+
+## Project Goals
+
+* Absolutely no dependency on ActiveSupport
+* Very small dependency tree
+* Framework agnostic
+* No built-in daemonization
+* No scheduling DSL
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem "scheduled"
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install scheduled
+
+## Usage
+
+### Defining tasks
+
+Tasks are defined by calling `Scheduled.every` with an interval and a block to execute.
+The interval can be a basic Integer to represent seconds, or a callable object that receives
+the current Job.
+
+If the callable object returns a truthy value, the block is executed.
+
+```ruby
+require "scheduled"
+
+# Called every 60 seconds
+Scheduled.every(60) { do_work } # Perform some job
+
+# Using a cronline
+Scheduled.every("* * * * *") { do_work }
+
+two_hours_from_last_run = ->(job) do
+  Time.now - job.last_run >= 60*60*2
+end
+Scheduled.every(two_hours_from_last_run) { puts "Updating" }
+
+# Run the scheduler
+Scheduled.wait
+```
+
+### Running the scheduler
+
+Provided your schedule file ends with a call to `Scheduled.wait`, just run it
+as any other Ruby script.
+
+    ruby schedule.rb
+
+### Quick Returning Tasks
+
+Scheduled works best if you schedule the tasks into a long-running queue, such as
+Backburner or Sidekiq.
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/adam12/scheduled.
+
+I love pull requests! If you fork this project and modify it, please ping me to see
+if your changes can be incorporated back into this project.
+
+That said, if your feature idea is nontrivial, you should probably open an issue to
+[discuss it](http://www.igvita.com/2011/12/19/dont-push-your-pull-requests/)
+before attempting a pull request.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).

data/lib/scheduled.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+require "concurrent"
+require "scheduled/cron_parser"
+
+module Scheduled
+  Job = Struct.new(:last_run)
+
+  module_function
+
+  def every(interval, &block)
+    if interval.is_a?(Integer)
+      task = Concurrent::TimerTask.new(execution_interval: interval, run_now: true) do
+        block.call
+      end
+
+      task.execute
+
+    elsif interval.is_a?(String)
+      run = ->() {
+        parsed_cron = CronParser.new(interval)
+        next_tick_delay = parsed_cron.next(Time.now) - Time.now
+
+        task = Concurrent::ScheduledTask.execute(next_tick_delay) do
+          block.call
+          run.call
+        end
+
+        task.execute
+      }
+
+      run.call
+
+    elsif interval.respond_to?(:call)
+      job = Job.new
+
+      task = Concurrent::TimerTask.new(execution_interval: 1, run_now: true) do |timer_task|
+        case interval.call(job)
+        when true
+          block.call
+
+          job.last_run = Time.now
+        when :cancel
+          timer_task.shutdown
+        end
+      end
+
+      task.execute
+    else
+      raise ArgumentError, "Unsupported value for interval"
+    end
+  end
+
+  def wait
+    trap("INT") { exit }
+
+    loop do
+      sleep 1
+    end
+  end
+end

data/lib/scheduled/cron_parser.rb

@@ -0,0 +1,322 @@
+# Original source available at
+# https://github.com/siebertm/parse-cron/blob/6064cc29262ac7c6ffb902c95c0c059eded960d1/lib/cron_parser.rb
+#
+# Copyright (C) 2013 Michael Siebert <siebertm85@googlemail.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 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.
+
+require 'set'
+require 'date'
+
+# Parses cron expressions and computes the next occurence of the "job"
+#
+class CronParser
+  # internal "mutable" time representation
+  class InternalTime
+    attr_accessor :year, :month, :day, :hour, :min
+    attr_accessor :time_source
+
+    def initialize(time,time_source = Time)
+      @year = time.year
+      @month = time.month
+      @day = time.day
+      @hour = time.hour
+      @min = time.min
+
+      @time_source = time_source
+    end
+
+    def to_time
+      time_source.local(@year, @month, @day, @hour, @min, 0)
+    end
+
+    def inspect
+      [year, month, day, hour, min].inspect
+    end
+  end
+
+  SYMBOLS = {
+     "jan" => "1",
+     "feb" => "2",
+     "mar" => "3",
+     "apr" => "4",
+     "may" => "5",
+     "jun" => "6",
+     "jul" => "7",
+     "aug" => "8",
+     "sep" => "9",
+     "oct" => "10",
+     "nov" => "11",
+     "dec" => "12",
+
+     "sun" => "0",
+     "mon" => "1",
+     "tue" => "2",
+     "wed" => "3",
+     "thu" => "4",
+     "fri" => "5",
+     "sat" => "6"
+  }
+
+  def initialize(source,time_source = Time)
+    @source = interpret_vixieisms(source)
+    @time_source = time_source
+    validate_source
+  end
+
+  def interpret_vixieisms(spec)
+    case spec
+    when '@reboot'
+      raise ArgumentError, "Can't predict last/next run of @reboot"
+    when '@yearly', '@annually'
+      '0 0 1 1 *'
+    when '@monthly'
+      '0 0 1 * *'
+    when '@weekly'
+      '0 0 * * 0'
+    when '@daily', '@midnight'
+      '0 0 * * *'
+    when '@hourly'
+      '0 * * * *'
+    else
+      spec
+    end
+  end
+
+
+  # returns the next occurence after the given date
+  def next(now = @time_source.now, num = 1)
+    t = InternalTime.new(now, @time_source)
+
+    unless time_specs[:month][0].include?(t.month)
+      nudge_month(t)
+      t.day = 0
+    end
+
+    unless interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+      nudge_date(t)
+      t.hour = -1
+    end
+
+    unless time_specs[:hour][0].include?(t.hour)
+      nudge_hour(t)
+      t.min = -1
+    end
+
+    # always nudge the minute
+    nudge_minute(t)
+    t = t.to_time
+    if num > 1
+      recursive_calculate(:next,t,num)
+    else
+      t
+    end
+  end
+
+  # returns the last occurence before the given date
+  def last(now = @time_source.now, num=1)
+    t = InternalTime.new(now,@time_source)
+
+    unless time_specs[:month][0].include?(t.month)
+      nudge_month(t, :last)
+      t.day = 32
+    end
+
+    if t.day == 32 || !interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+      nudge_date(t, :last)
+      t.hour = 24
+    end
+
+    unless time_specs[:hour][0].include?(t.hour)
+      nudge_hour(t, :last)
+      t.min = 60
+    end
+
+    # always nudge the minute
+    nudge_minute(t, :last)
+    t = t.to_time
+    if num > 1
+      recursive_calculate(:last,t,num)
+    else
+      t
+    end
+  end
+
+
+  SUBELEMENT_REGEX = %r{^(\d+)(-(\d+)(/(\d+))?)?$}
+  def parse_element(elem, allowed_range)
+    values = elem.split(',').map do |subel|
+      if subel =~ /^\*/
+        step = subel.length > 1 ? subel[2..-1].to_i : 1
+        stepped_range(allowed_range, step)
+      else
+        if SUBELEMENT_REGEX === subel
+          if $5 # with range
+            stepped_range($1.to_i..$3.to_i, $5.to_i)
+          elsif $3 # range without step
+            stepped_range($1.to_i..$3.to_i, 1)
+          else # just a numeric
+            [$1.to_i]
+          end
+        else
+          raise ArgumentError, "Bad Vixie-style specification #{subel}"
+        end
+      end
+    end.flatten.sort
+
+    [Set.new(values), values, elem]
+  end
+
+
+  protected
+
+  def recursive_calculate(meth,time,num)
+    array = [time]
+    num.-(1).times do |num|
+      array << self.send(meth, array.last)
+    end
+    array
+  end
+
+  # returns a list of days which do both match time_spec[:dom] or time_spec[:dow]
+  def interpolate_weekdays(year, month)
+    @_interpolate_weekdays_cache ||= {}
+    @_interpolate_weekdays_cache["#{year}-#{month}"] ||= interpolate_weekdays_without_cache(year, month)
+  end
+
+  def interpolate_weekdays_without_cache(year, month)
+    t = Date.new(year, month, 1)
+    valid_mday, _, mday_field = time_specs[:dom]
+    valid_wday, _, wday_field = time_specs[:dow]
+
+    # Careful, if both DOW and DOM fields are non-wildcard,
+    # then we only need to match *one* for cron to run the job:
+    if not (mday_field == '*' and wday_field == '*')
+      valid_mday = [] if mday_field == '*'
+      valid_wday = [] if wday_field == '*'
+    end
+    # Careful: crontabs may use either 0 or 7 for Sunday:
+    valid_wday << 0 if valid_wday.include?(7)
+
+    result = []
+    while t.month == month
+      result << t.mday if valid_mday.include?(t.mday) || valid_wday.include?(t.wday)
+      t = t.succ
+    end
+
+    [Set.new(result), result]
+  end
+
+  def nudge_year(t, dir = :next)
+    t.year = t.year + (dir == :next ? 1 : -1)
+  end
+
+  def nudge_month(t, dir = :next)
+    spec = time_specs[:month][1]
+    next_value = find_best_next(t.month, spec, dir)
+    t.month = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_year(t, dir) if next_value.nil?
+
+    # we changed the month, so its likely that the date is incorrect now
+    valid_days = interpolate_weekdays(t.year, t.month)[1]
+    t.day = dir == :next ? valid_days.first : valid_days.last
+  end
+
+  def date_valid?(t, dir = :next)
+    interpolate_weekdays(t.year, t.month)[0].include?(t.day)
+  end
+
+  def nudge_date(t, dir = :next, can_nudge_month = true)
+    spec = interpolate_weekdays(t.year, t.month)[1]
+    next_value = find_best_next(t.day, spec, dir)
+    t.day = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_month(t, dir) if next_value.nil? && can_nudge_month
+  end
+
+  def nudge_hour(t, dir = :next)
+    spec = time_specs[:hour][1]
+    next_value = find_best_next(t.hour, spec, dir)
+    t.hour = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_date(t, dir) if next_value.nil?
+  end
+
+  def nudge_minute(t, dir = :next)
+    spec = time_specs[:minute][1]
+    next_value = find_best_next(t.min, spec, dir)
+    t.min = next_value || (dir == :next ? spec.first : spec.last)
+
+    nudge_hour(t, dir) if next_value.nil?
+  end
+
+  def time_specs
+    @time_specs ||= begin
+      # tokens now contains the 5 fields
+      tokens = substitute_parse_symbols(@source).split(/\s+/)
+      {
+        :minute => parse_element(tokens[0], 0..59), #minute
+        :hour   => parse_element(tokens[1], 0..23), #hour
+        :dom    => parse_element(tokens[2], 1..31), #DOM
+        :month  => parse_element(tokens[3], 1..12), #mon
+        :dow    => parse_element(tokens[4], 0..6)  #DOW
+      }
+    end
+  end
+
+  def substitute_parse_symbols(str)
+    SYMBOLS.inject(str.downcase) do |s, (symbol, replacement)|
+      s.gsub(symbol, replacement)
+    end
+  end
+
+
+  def stepped_range(rng, step = 1)
+    len = rng.last - rng.first
+
+    num = len.div(step)
+    result = (0..num).map { |i| rng.first + step * i }
+
+    result.pop if result[-1] == rng.last and rng.exclude_end?
+    result
+  end
+
+
+  # returns the smallest element from allowed which is greater than current
+  # returns nil if no matching value was found
+  def find_best_next(current, allowed, dir)
+    if dir == :next
+      allowed.sort.find { |val| val > current }
+    else
+      allowed.sort.reverse.find { |val| val < current }
+    end
+  end
+
+  def validate_source
+    unless @source.respond_to?(:split)
+      raise ArgumentError, 'not a valid cronline'
+    end
+    source_length = @source.split(/\s+/).length
+    unless source_length >= 5 && source_length <= 6
+      raise ArgumentError, 'not a valid cronline'
+    end
+  end
+end

data/lib/scheduled/version.rb

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+module Scheduled
+  VERSION = "0.1.0"
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: scheduled
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Adam Daniels
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-06-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: concurrent-ruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rubygems-tasks
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.2'
+description: 
+email: adam@mediadrive.ca
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- lib/scheduled.rb
+- lib/scheduled/cron_parser.rb
+- lib/scheduled/version.rb
+homepage: https://github.com/adam12/scheduled
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.12
+signing_key: 
+specification_version: 4
+summary: A very lightweight clock process with minimal dependencies and no magic.
+test_files: []