lita-task-scheduler 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 23f66b45e3100b728a6a53a23fa9f166552d7989
-  data.tar.gz: 4b23ad6c9ed0638905152bb6ac960fa98978a47d
+  metadata.gz: c87964e095867fd79b29baed0c909bea11c627b8
+  data.tar.gz: c594c7eae944748bcd509e50214814edc629f2fe
 SHA512:
-  metadata.gz: 468d8b5438c5d815e570d72d14c727b093f7d584104017c459b1c0a72d2ec6097fba77df538f2e02acfccb7e1615c3b7ab130419845363dbd23ffcc12aff929d
-  data.tar.gz: 969dc2317064912351a8bdf4af531fd0e1095186d4100298587b298c0cf5c027339672e2311ad08481dad6757b178ec8f4df5d897e5dbd54ee54739f4acb6c6e
+  metadata.gz: 407c632bfb744874758e04fa94fdc2af7e69cdea4bbd9d13fdc2ec02c3fb1d25031ced5f2596b1f0e3e5c69b2831d4024247193b2062adb469bbe44147da4658
+  data.tar.gz: 8c25068482aadcee6efbbab58aa09085167a71d09758516f43efcb0537be13d218b8565e379e090ec591372fd3a174a7abd49274ee9384450373a4f9b612e186

data/lib/lita/handlers/task_scheduler.rb

@@ -1,29 +1,41 @@
-require 'pry'
-require 'json'
+require 'lita/scheduler'
 
 module Lita
   module Handlers
     class TaskScheduler < Handler
 
+      # START:routes
       route(/^schedule\s+"(.+)"\s+in\s+(.+)$/i, :schedule_command, command: true)
       route(/^show schedule$/i, :show_schedule, command: true)
       route(/^empty schedule$/i, :empty_schedule, command: true)
+      # END:routes
 
-      REDIS_TASKS_KEY = name.to_s
-
+      # START:handlers
       def show_schedule(payload)
-        schedule = redis.hgetall(REDIS_TASKS_KEY)
-
-        payload.reply schedule_report(schedule)
+        payload.reply schedule_report(scheduler.get_all)
       end
 
       def empty_schedule(payload)
-        redis.del(REDIS_TASKS_KEY)
+        scheduler.clear
+        show_schedule payload
+      end
+
+      # START:schedule_command
+      def schedule_command(payload)
+        task, timing = payload.matches.last
+        run_at = parse_timing(timing)
+        serialized = command_to_hash(payload.message, new_body: task)
+
+        defer_task(serialized, run_at)
         show_schedule payload
       end
+      # END:schedule_command
+
+      def scheduler
+        @_schedule ||= Scheduler.new(redis: redis, logger: Lita.logger)
+      end
 
       def schedule_report(schedule)
-        reply = 'Scheduled tasks: '
         descriptions = []
 
         schedule.keys.each do |timestamp|
@@ -36,75 +48,16 @@ module Lita
           end
         end
 
-        reply + (descriptions.empty? ? 'None.' : descriptions.join)
-      end
-
-      def schedule_command(payload)
-        task, timing = payload.matches.last
-        run_at = parse_timing(timing)
-        serialized = serialize_message(payload.message, new_body: task)
-
-        defer_task(serialized, run_at)
-        show_schedule(payload)
+        'Scheduled tasks: ' + (descriptions.empty? ? 'None.' : descriptions.join)
       end
 
+      # START:defer_task
       def defer_task(serialized_task, run_at)
-        key_time = run_at.to_i.to_s
-
-        redis.watch(REDIS_TASKS_KEY)
-
-        tasks = redis.hget(REDIS_TASKS_KEY, key_time) || []
-
-        tasks = JSON.parse(tasks) unless tasks.empty?
-        tasks << serialized_task
-
-        redis.hset(REDIS_TASKS_KEY, key_time, tasks.to_json)
-
-        redis.unwatch
-
-        tasks
-      end
-
-      def execute_tasks(serialized_tasks)
-        serialized_tasks.each do |serialized_task|
-          Lita.logger.debug "Resending task #{serialized_task}"
-          resend serialized_task
-        end
-      end
-
-      def run_loop
-        Thread.new do
-          loop do
-            tick
-            sleep 1
-          end
-        end
-      end
-
-      def tick
-        tasks = find_tasks_due
-        tasks.each { |t| resend t }
-        Lita.logger.debug "Task loop done for #{Time.now}"
-      end
-
-      def find_tasks_due
-        results = []
-        timestamps = redis.hkeys(REDIS_TASKS_KEY)
-
-        timestamps.each do |t|
-          key_time = Time.at(t.to_i)
-          next unless key_time <= Time.now
-
-          tasks_raw = redis.hget(REDIS_TASKS_KEY, t)
-          tasks = JSON.parse(tasks_raw)
-
-          results += tasks
-          redis.hdel(REDIS_TASKS_KEY, t)
-        end
-
-        results
+        scheduler.add(serialized_task, run_at)
       end
+      # END:defer_task
 
+      # START:parse_timing
       def parse_timing(timing)
         count, unit = timing.split
         count = count.to_i
@@ -125,22 +78,14 @@ module Lita
 
         Time.now.utc + seconds
       end
+      # END:parse_timing
 
-      def rebroadcast(payload)
-        serialized = serialize_message(payload.message)
-
-        key = "delay_#{rand(100..10_000)}"
-        redis.set(key, serialized.to_json)
-        reloaded = JSON.parse redis.get(key), symbolize_names: true
-
-        resend(reloaded)
-      end
-
-      def resend(serialized)
-        user = Lita::User.new(serialized.fetch('user_name'))
-        room = Lita::Room.new(serialized.fetch('room_name'))
+      # START:resend_command
+      def resend_command(command_hash)
+        user = Lita::User.new(command_hash.fetch('user_name'))
+        room = Lita::Room.new(command_hash.fetch('room_name'))
         source = Lita::Source.new(user: user, room: room)
-        body = "#{robot.name} #{serialized.fetch('body')}"
+        body = "#{robot.name} #{command_hash.fetch('body')}"
 
         newmsg = Lita::Message.new(
           robot,
@@ -150,20 +95,42 @@ module Lita
 
         robot.receive newmsg
       end
+      # END:resend_command
 
-      def serialize_message(message, new_body: nil)
+      # START:serialize_message
+      def command_to_hash(command, new_body: nil)
         {
-          user_name: message.user.name,
-          room_name: message.source.room,
-          body: new_body || message.body
+          user_name: command.user.name,
+          room_name: command.source.room,
+          body: new_body || command.body
         }
       end
+      # END:serialize_message
 
-      Lita.register_handler(self)
+      def find_tasks_due
+        scheduler.find_tasks_due
+      end
+
+      # START:loop_ticks
+      def run_loop
+        Thread.new do
+          loop do
+            tick
+            sleep 1
+          end
+        end
+      end
 
-      on :loaded do
-        run_loop
+      def tick
+        tasks = find_tasks_due
+        tasks.each { |t| resend_command t }
+        Lita.logger.debug "Task loop done for #{Time.now}"
       end
+
+      on(:loaded) { run_loop }
+      # END:loop_ticks
+
+      Lita.register_handler(self)
     end
   end
 end

data/lib/lita/scheduler.rb

@@ -0,0 +1,62 @@
+require 'json'
+
+# START:preamble
+module Lita
+  class Scheduler
+    REDIS_TASKS_KEY = name.to_s
+
+    def initialize(redis:, logger:)
+      @redis = redis
+      @logger = logger
+    end
+
+    attr_reader :redis, :logger
+
+    def get_all
+      redis.hgetall(REDIS_TASKS_KEY)
+    end
+    # END:preamble
+
+    # START:store_new
+    def add(payload, timestamp)
+      key_time = timestamp.to_i.to_s
+
+      redis.watch(REDIS_TASKS_KEY)
+
+      tasks = redis.hget(REDIS_TASKS_KEY, key_time) || []
+
+      tasks = JSON.parse(tasks) unless tasks.empty?
+      tasks << payload
+
+      redis.hset(REDIS_TASKS_KEY, key_time, tasks.to_json)
+
+      redis.unwatch
+      tasks
+    end
+    # END:store_new
+
+    def clear
+      redis.del(REDIS_TASKS_KEY)
+    end
+
+    # START:find_tasks_due
+    def find_tasks_due
+      results = []
+      timestamps = redis.hkeys(REDIS_TASKS_KEY)
+
+      timestamps.each do |t|
+        key_time = Time.at(t.to_i)
+        next unless key_time <= Time.now
+
+        tasks_raw = redis.hget(REDIS_TASKS_KEY, t)
+        tasks = JSON.parse(tasks_raw)
+
+        results += tasks
+        redis.hdel(REDIS_TASKS_KEY, t)
+      end
+
+      results
+    end
+    # END:find_tasks_due
+  end
+end

data/lita-task-scheduler.gemspec

@@ -1,6 +1,6 @@
 Gem::Specification.new do |spec|
   spec.name          = "lita-task-scheduler"
-  spec.version       = "1.0.0"
+  spec.version       = "1.1.0"
   spec.authors       = ["Daniel J. Pritchett"]
   spec.email         = ["dpritchett@gmail.com"]
   spec.description   = "Schedule jobs in Lita"

data/spec/lita/handlers/task_scheduler_spec.rb

@@ -2,13 +2,17 @@ require 'spec_helper'
 
 describe Lita::Handlers::TaskScheduler, lita_handler: true do
   let(:robot) { Lita::Robot.new(registry) }
+  before(:suite) { subject.scheduler.clear }
 
   subject { described_class.new(robot) }
 
+  # START:routes
   describe 'routing' do
-    it { is_expected.to route('Lita schedule "show schedule" in 2 hours') }
+    it { is_expected.to route('Lita schedule "double 4" in 2 hours') }
     it { is_expected.to route('Lita show schedule') }
+    it { is_expected.to route('Lita empty schedule') }
   end
+  # END:routes
 
   describe 'functionality' do
 
@@ -27,6 +31,7 @@ describe Lita::Handlers::TaskScheduler, lita_handler: true do
       end
     end
 
+    # START: defer_task
     describe ':defer_task' do
       it 'defers any single task' do
         message = { canary_message: Time.now }
@@ -48,7 +53,9 @@ describe Lita::Handlers::TaskScheduler, lita_handler: true do
         expect(result).to eq([message] * 6)
       end
     end
+    # END: defer_task
 
+    # START:find_tasks_due
     describe ':find_tasks_due' do
       context 'two tasks are scheduled for five seconds ago' do
         before { 2.times { subject.defer_task('past_task', Time.now - 5) } }
@@ -69,28 +76,23 @@ describe Lita::Handlers::TaskScheduler, lita_handler: true do
         end
       end
     end
+    # END:find_tasks_due
   end
 
-  describe 'execute_tasks' do
-    it 'resends each task' do
-      tasks = [{}, {}]
-
-      expect(subject).to receive(:resend).exactly(2).times
-      subject.execute_tasks(tasks)
-    end
-  end
-
+  # START:loop_ticks
   describe 'tick' do
     before { subject.stub(:find_tasks_due).and_return ['a_task'] }
 
     it 'should find tasks due and resend them' do
       expect(subject).to receive(:find_tasks_due)
-      expect(subject).to receive(:resend).with('a_task')
+      expect(subject).to receive(:resend_command).with('a_task')
 
       subject.tick
     end
   end
+  # END:loop_ticks
 
+  # START:parse_timing
   describe ':parse_timing' do
     def time_drift(time, expected_seconds:)
       delta = (Time.now.utc - time).abs
@@ -112,4 +114,5 @@ describe Lita::Handlers::TaskScheduler, lita_handler: true do
       end
     end
   end
+  # END:parse_timing
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-task-scheduler
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.1.0
 platform: ruby
 authors:
 - Daniel J. Pritchett
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-07 00:00:00.000000000 Z
+date: 2018-05-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -121,6 +121,7 @@ files:
 - Rakefile
 - lib/lita-task-scheduler.rb
 - lib/lita/handlers/task_scheduler.rb
+- lib/lita/scheduler.rb
 - lita-task-scheduler.gemspec
 - locales/en.yml
 - spec/lita/handlers/task_scheduler_spec.rb