lita-locker 0.7.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c652f7dfc79a47babe632a2f9516bfeedf1b4781
-  data.tar.gz: d4f5f7802f48182a08fab5f573f44b35ecac6b90
+  metadata.gz: 932d1d2d4b5f788199bd0b8d3ea0884987fd8dec
+  data.tar.gz: f677dbe6a38e68ed8fa1485445bd89e037ea61c5
 SHA512:
-  metadata.gz: c9113338335470eca38f6b2b947618b115c624ffeea5dc81acf94e43636bb1aaecc359f00128653784aace1ed48647e2da0ec5dad5318d90b533e361d66a5fe5
-  data.tar.gz: 2acb94c1f70b702c67baedb3e2cd8095a68c79517c1ec46e57558e8d755e18a203bc5d6987181301999ce1e67aada7cb028fe91289291e0a55bf650b50dad748
+  metadata.gz: cd4694f2fe5c4247b918c1e59afda10d6ab1417c7938eb057d33560eb7d6fff3dc58f4fb63025cf2435c006e7b308c10ce37a342187c4d2d244972551273fe23
+  data.tar.gz: c0aa1d169d48406afb06f513efcb244b5df5f6b9dd05c22e0215c9efe9505deff2976efcf8fa0dc487d553a87467d7b8937b732f75941daa0fd51c2656c8aac7

data/.rubocop.yml

@@ -1,21 +1,15 @@
-ClassLength:
-  Max: 103
-
-CyclomaticComplexity:
-  Max: 7
-
 FileName:
   Exclude:
     - lib/lita-locker.rb
 
-MethodLength:
- Max: 31
-
-PerceivedComplexity:
-  Max: 12
-
 LineLength:
-  Max: 120
+  Max: 130
 
 AbcSize:
-  Max: 49
+  Max: 30
+
+MethodLength:
+  Max: 20
+
+ClassLength:
+  Max: 150

data/.travis.yml

@@ -1,8 +1,8 @@
 language: ruby
 rvm:
   - 2.1
-script: bundle exec rake
-before_install:
-  - gem update --system
+  - 2.2
+cache: bundler
+sudo: false
 services:
   - redis-server

data/README.md

@@ -43,15 +43,10 @@ unlock <label>       - Remove a reservation.  This can only be done by whomever
 steal <label>        - Force removal of a reservation.  This can be done by anyone. Can have # comments afterwards.
 ```
 
-### Time-based locking - Not implemented yet!
+### Queueing
 ```
-lock <subject> <time>        - A time-limited reservation.  <time> must be a number with a "s", "m", or "h" postfix.
-```
-
-### Reservations - Not implemented yet!
-```
-reserve <subject> - Add yourself to a FIFO queue of pending reservations for <subject>
-unreserve <subject> - Remove yourself from the queue for <subject>
+lock <label> - If <label> is already locked, adds you to a FIFO queue of pending reservations for <label>
+locker dequeue <label> - Remove yourself from the queue for <label>
 ```
 
 ### Labels

data/UPGRADING.md

@@ -0,0 +1,61 @@
+# lita-locker upgrading
+
+## Overview
+
+lita-locker 1.x has a breaking data model change.  This enables a huge number
+of new features, such as queueing and timestamps.  You'll need to export out
+your existing data and bring it back in when you upgrade lita-locker.
+
+As a note, the 0.x and 1.x plugins use different redis keysets, so it's possible
+to upgrade to 1.x and retain your old data, should you need to downgrade for
+some reason.  However, 1.x locks will not show up in 0.x clients, and vice-versa.
+
+## Example migration script
+
+The below is a no-warranties-provided Ruby script you can use to export your
+existing data, and optionally remove the older information.
+
+``
+require 'redis'
+
+bot_prefix = "!"
+remove_old_data = false
+redis = Redis.new
+resources = []
+labels = []
+
+redis.keys('lita:handlers:locker:resource_*').each do |k|
+  resources.push(k.gsub(/^lita:handlers:locker:resource_/, ''))
+end
+
+resources.each_slice(10) do |batch|
+  puts "#{bot_prefix}locker resource create #{batch.join(', ')}\n\n"
+end
+
+redis.keys('lita:handlers:locker:label_*').each do |k|
+  labels.push(k.gsub(/^lita:handlers:locker:label_/, ''))
+end
+
+labels.each_slice(10) do |batch|
+  puts "#{bot_prefix}locker label create #{batch.join(', ')}\n\n"
+end
+
+labels.each do |label|
+  members = []
+  redis.smembers("lita:handlers:locker:membership_#{label}").each do |k|
+    members.push(k)
+  end
+  puts "#{bot_prefix}locker label add #{members.join(', ')} to #{label}\n" if members.count > 0
+end
+
+if remove_old_data
+  resources.each do |r|
+    redis.del("lita:handlers:locker:resource_#{r}")
+  end
+
+  labels.each do |l|
+    redis.del("lita:handlers:locker:label_#{l}")
+    redis.del("lita:handlers:locker:membership_#{l}")
+  end
+end
+``

data/lib/lita/handlers/locker.rb

@@ -3,6 +3,8 @@ module Lita
   module Handlers
     # Top-level class for Locker
     class Locker < Handler
+      on :loaded, :setup_redis
+
       include ::Locker::Label
       include ::Locker::Misc
       include ::Locker::Regex
@@ -39,82 +41,63 @@ module Lita
         help: { t('help.steal.syntax') => t('help.steal.desc') }
       )
 
+      def setup_redis(_payload)
+        Label.redis = redis
+        Resource.redis = redis
+      end
+
       def lock(response)
-        name = response.matches[0][0]
-
-        return response.reply('(failed) ' + t('label.does_not_exist', name: name)) unless label_exists?(name)
-        m = label_membership(name)
-        return response.reply('(failed) ' + t('label.no_resources', name: name)) unless m.count > 0
-        return response.reply('(successful) ' + t('label.lock', name: name)) if lock_label!(name, response.user, nil)
-
-        l = label(name)
-        if l['state'] == 'locked'
-          o = Lita::User.find_by_id(l['owner_id'])
-          if o.mention_name
-            response.reply('(failed) ' + t('label.owned_mention',
-                                           name: name,
-                                           owner_name: o.name,
-                                           owner_mention: o.mention_name))
-          else
-            response.reply('(failed) ' + t('label.owned',
-                                           name: name,
-                                           owner_name: o.name))
-          end
-        else
-          msg = '(failed) ' + t('label.dependency') + "\n"
-          deps = []
-          label_membership(name).each do |resource_name|
-            resource = resource(resource_name)
-            u = Lita::User.find_by_id(resource['owner_id'])
-            if resource['state'] == 'locked'
-              deps.push "#{resource_name} - #{u.name}"
-            end
-          end
-          msg += deps.join("\n")
-          response.reply(msg)
-        end
+        name = response.match_data['label']
+
+        return response.reply(failed(t('label.does_not_exist', name: name))) unless Label.exists?(name)
+        l = Label.new(name)
+        return response.reply(failed(t('label.no_resources', name: name))) unless l.membership.count > 0
+        return response.reply(t('label.self_lock', name: name)) if l.owner == response.user
+        return response.reply(success(t('label.lock', name: name))) if l.lock!(response.user.id)
+
+        response.reply(label_ownership(name))
       end
 
       def unlock(response)
-        name = response.matches[0][0]
-        return response.reply('(failed) ' + t('subject.does_not_exist', name: name)) unless label_exists?(name)
-        l = label(name)
-        return response.reply('(successful) ' + t('label.is_unlocked', name: name)) if l['state'] == 'unlocked'
-
-        if response.user.id == l['owner_id']
-          unlock_label!(name)
-          response.reply('(successful) ' + t('label.unlock', name: name))
-        else
-          o = Lita::User.find_by_id(l['owner_id'])
-          if o.mention_name
-            response.reply('(failed) ' + t('label.owned_mention',
-                                           name: name,
-                                           owner_name: o.name,
-                                           owner_mention: o.mention_name))
-          else
-            response.reply('(failed) ' + t('label.owned',
-                                           name: name,
-                                           owner_name: o.name))
-          end
-        end
+        name = response.match_data['label']
+        return response.reply(failed(t('subject.does_not_exist', name: name))) unless Label.exists?(name)
+        l = Label.new(name)
+        return response.reply(success(t('label.is_unlocked', name: name))) unless l.locked?
+        response.reply(attempt_unlock(name, response.user))
       end
 
       def steal(response)
-        name = response.matches[0][0]
-        return response.reply('(failed) ' + t('subject.does_not_exist', name: name)) unless label_exists?(name)
-        l = label(name)
-        return response.reply(t('steal.already_unlocked', label: name)) unless l['state'] == 'locked'
-        o = Lita::User.find_by_id(l['owner_id'])
-        if o.id != response.user.id
-          unlock_label!(name)
-          lock_label!(name, response.user, nil)
-          mention = o.mention_name ? "(@#{o.mention_name})" : ''
-          response.reply('(successful) ' + t('steal.stolen',
-                                             label: name,
-                                             old_owner: o.name,
-                                             mention: mention))
+        name = response.match_data['label']
+        return response.reply(failed(t('subject.does_not_exist', name: name))) unless Label.exists?(name)
+        l = Label.new(name)
+        return response.reply(t('steal.already_unlocked', label: name)) unless l.locked?
+        response.reply(attempt_steal(name, response.user))
+      end
+
+      private
+
+      def attempt_steal(name, user)
+        label = Label.new(name)
+        return t('steal.self') if label.owner == user
+        old_owner = label.owner
+        label.steal!(user.id)
+        mention = old_owner.mention_name ? "(@#{old_owner.mention_name})" : ''
+        success(t('steal.stolen', label: name, old_owner: old_owner.name, mention: mention))
+      end
+
+      def attempt_unlock(name, user)
+        label = Label.new(name)
+        if label.owner == user
+          label.unlock!
+          if label.locked?
+            mention = label.owner.mention_name ? "(@#{label.owner.mention_name})" : ''
+            failed(t('label.now_locked_by', name: name, owner: label.owner.name, mention: mention))
+          else
+            success(t('label.unlock', name: name))
+          end
         else
-          response.reply(t('steal.self'))
+          mention = label.owner.mention_name ? "(@#{label.owner.mention_name})" : ''
+          failed(t('label.owned_unlock', name: name, owner_name: label.owner.name, mention: mention, time: label.held_for))
         end
       end
     end

data/lib/lita/handlers/locker_events.rb

@@ -17,7 +17,9 @@ module Lita
         user       = Lita::User.find_by_id(payload[:user_id])
         request_id = payload[:request_id]
 
-        if label_exists?(label) && lock_label!(label, user, nil)
+        return unless Label.exists?(label)
+        l = Label.new(label)
+        if l.lock!(user.id)
           robot.trigger(:lock_success, request_id: request_id)
         else
           robot.trigger(:lock_failure, request_id: request_id)
@@ -28,7 +30,9 @@ module Lita
         label      = payload[:label]
         request_id = payload[:request_id]
 
-        if label_exists?(label) && unlock_label!(label)
+        return unless Label.exists?(label)
+        l = Label.new(label)
+        if l.unlock!
           robot.trigger(:unlock_success, request_id: request_id)
         else
           robot.trigger(:unlock_failure, request_id: request_id)

data/lib/lita/handlers/locker_http.rb

@@ -9,19 +9,29 @@ module Lita
       include ::Locker::Regex
       include ::Locker::Resource
 
-      http.get '/locker/label/:name', :http_label_show
-      http.get '/locker/resource/:name', :http_resource_show
+      http.get '/locker/label/:name', :label_show
+      http.get '/locker/resource/:name', :resource_show
 
-      def http_label_show(request, response)
+      def label_show(request, response)
         name = request.env['router.params'][:name]
         response.headers['Content-Type'] = 'application/json'
-        response.write(label(name).to_json)
+        unless Label.exists?(name)
+          response.status = 404
+          return
+        end
+        l = Label.new(name)
+        response.write(l.to_json)
       end
 
-      def http_resource_show(request, response)
+      def resource_show(request, response)
         name = request.env['router.params'][:name]
         response.headers['Content-Type'] = 'application/json'
-        response.write(resource(name).to_json)
+        unless Resource.exists?(name)
+          response.status = 404
+          return
+        end
+        r = Resource.new(name)
+        response.write(r.to_json)
       end
 
       Lita.register_handler(LockerHttp)

data/lib/lita/handlers/locker_labels.rb

@@ -17,14 +17,14 @@ module Lita
       )
 
       route(
-        /^locker\slabel\screate\s#{LABEL_REGEX}$/,
+        /^locker\slabel\screate\s#{LABELS_REGEX}$/,
         :create,
         command: true,
         help: { t('help.label.create.syntax') => t('help.label.create.desc') }
       )
 
       route(
-        /^locker\slabel\sdelete\s#{LABEL_REGEX}$/,
+        /^locker\slabel\sdelete\s#{LABELS_REGEX}$/,
         :delete,
         command: true,
         help: { t('help.label.delete.syntax') => t('help.label.delete.desc') }
@@ -38,74 +38,120 @@ module Lita
       )
 
       route(
-        /^locker\slabel\sadd\s#{RESOURCE_REGEX}\sto\s#{LABEL_REGEX}$/,
+        /^locker\slabel\sadd\s#{RESOURCES_REGEX}\sto\s#{LABEL_REGEX}$/,
         :add,
         command: true,
         help: { t('help.label.add.syntax') => t('help.label.add.desc') }
       )
 
       route(
-        /^locker\slabel\sremove\s#{RESOURCE_REGEX}\sfrom\s#{LABEL_REGEX}$/,
+        /^locker\slabel\sremove\s#{RESOURCES_REGEX}\sfrom\s#{LABEL_REGEX}$/,
         :remove,
         command: true,
         help: { t('help.label.remove.syntax') => t('help.label.remove.desc') }
       )
 
       def list(response)
-        labels.sort.each do |n|
-          name = n.sub('label_', '')
-          l = label(name)
-          response.reply(t('label.desc', name: name, state: l['state']))
+        should_rate_limit = false
+
+        Label.list.each_slice(10) do |slice|
+          if should_rate_limit
+            sleep 1
+          else
+            should_rate_limit = true
+          end
+
+          slice.each do |n|
+            l = Label.new(n)
+            response.reply(unlocked(t('label.desc', name: n, state: l.state.value)))
+          end
         end
       end
 
       def create(response)
-        name = response.matches[0][0]
-        if create_label(name)
-          response.reply(t('label.created', name: name))
-        else
-          response.reply(t('label.exists', name: name))
+        names = response.match_data['labels'].split(/,\s*/)
+        results = []
+
+        names.each do |name|
+          if !Label.exists?(name) && Label.create(name)
+            results <<= t('label.created', name: name)
+          else
+            results <<= t('label.exists', name: name)
+          end
         end
+
+        response.reply(results.join(', '))
       end
 
       def delete(response)
-        name = response.matches[0][0]
-        if delete_label(name)
-          response.reply(t('label.deleted', name: name))
-        else
-          response.reply(t('label.does_not_exist', name: name))
+        names = response.match_data['labels'].split(/,\s*/)
+        results = []
+
+        names.each do |name|
+          if Label.exists?(name) && Label.delete(name)
+            results <<= t('label.deleted', name: name)
+          else
+            results <<= failed(t('label.does_not_exist', name: name))
+          end
         end
+
+        response.reply(results.join(', '))
       end
 
       def show(response)
-        name = response.matches[0][0]
-        return response.reply(t('label.does_not_exist', name: name)) unless label_exists?(name)
-        members = label_membership(name)
-        return response.reply(t('label.has_no_resources', name: name)) unless members.count > 0
-        response.reply(t('label.resources', name: name, resources: members.join(', ')))
+        name = response.match_data['label']
+        return response.reply(failed(t('label.does_not_exist', name: name))) unless Label.exists?(name)
+        l = Label.new(name)
+        return response.reply(t('label.has_no_resources', name: name)) unless l.membership.count > 0
+        res = []
+        l.membership.each do |member|
+          res.push(member)
+        end
+        response.reply(t('label.resources', name: name, resources: res.join(', ')))
       end
 
       def add(response)
-        resource_name = response.matches[0][0]
-        label_name = response.matches[0][1]
-        return response.reply(t('label.does_not_exist', name: label_name)) unless label_exists?(label_name)
-        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
-        add_resource_to_label(label_name, resource_name)
-        response.reply(t('label.resource_added', label: label_name, resource: resource_name))
+        results = []
+        resource_names = response.match_data['resources'].split(/,\s*/)
+        label_name = response.match_data['label']
+        return response.reply(failed(t('label.does_not_exist', name: label_name))) unless Label.exists?(label_name)
+
+        resource_names.each do |resource_name|
+          if Resource.exists?(resource_name)
+            l = Label.new(label_name)
+            r = Resource.new(resource_name)
+            l.add_resource(r)
+            results <<= t('label.resource_added', label: label_name, resource: resource_name)
+          else
+            results <<= t('resource.does_not_exist', name: resource_name)
+          end
+        end
+
+        response.reply(results.join(', '))
       end
 
       def remove(response)
-        resource_name = response.matches[0][0]
-        label_name = response.matches[0][1]
-        return response.reply(t('label.does_not_exist', name: label_name)) unless label_exists?(label_name)
-        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
-        members = label_membership(label_name)
-        if members.include?(resource_name)
-          remove_resource_from_label(label_name, resource_name)
-          response.reply(t('label.resource_removed', label: label_name, resource: resource_name))
-        else
-          response.reply(t('label.does_not_have_resource', label: label_name, resource: resource_name))
+        results = []
+        resource_names = response.match_data['resources'].split(/,\s*/)
+        label_name = response.match_data['label']
+        return response.reply(failed(t('label.does_not_exist', name: label_name))) unless Label.exists?(label_name)
+
+        resource_names.each do |resource_name|
+          if Resource.exists?(resource_name)
+            l = Label.new(label_name)
+            if l.membership.include?(resource_name)
+              r = Resource.new(resource_name)
+              l.remove_resource(r)
+              results <<= t('label.resource_removed', label: label_name, resource: resource_name)
+            else
+              results <<= t('label.does_not_have_resource', label: label_name, resource: resource_name)
+            end
+          else
+            results <<= t('resource.does_not_exist', name: resource_name)
+          end
         end
+
+        response.reply(results.join(', '))
       end
 
       Lita.register_handler(LockerLabels)

data/lib/lita/handlers/locker_misc.rb

@@ -23,32 +23,50 @@ module Lita
         help: { t('help.list.syntax') => t('help.list.desc') }
       )
 
-      def status(response)
-        name = response.matches[0][0]
-        if label_exists?(name)
-          l = label(name)
-          if l['owner_id'] && l['owner_id'] != ''
-            o = Lita::User.find_by_id(l['owner_id'])
-            response.reply(t('label.desc_owner', name: name,
-                                                 state: l['state'],
-                                                 owner_name: o.name))
-          else
-            response.reply(t('label.desc', name: name, state: l['state']))
-          end
-        elsif resource_exists?(name)
-          r = resource(name)
-          response.reply(t('resource.desc', name: name, state: r['state']))
-        else
-          response.reply(t('subject.does_not_exist', name: name))
+      route(
+        /^locker\sdequeue\s#{LABEL_REGEX}$/,
+        :dequeue,
+        command: true,
+        help: { t('help.dequeue.syntax') => t('help.dequeue.desc') }
+      )
+
+      route(
+        /^locker\slog\s#{LABEL_REGEX}$/,
+        :log,
+        command: true,
+        help: { t('help.log.syntax.') => t('help.log.desc') }
+      )
+
+      def log(response)
+        name = response.match_data['label']
+        return response.reply(failed(t('subject.does_not_exist', name: name))) unless Label.exists?(name)
+        l = Label.new(name)
+        l.journal.range(-10, -1).each do |entry|
+          response.reply(t('label.log_entry', entry: entry))
         end
       end
 
+      def status(response)
+        name = response.match_data['label']
+        return response.reply(status_label(name)) if Label.exists?(name)
+        return response.reply(status_resource(name)) if Resource.exists?(name)
+        response.reply(failed(t('subject.does_not_exist', name: name)))
+      end
+
+      def dequeue(response)
+        name = response.match_data['label']
+        return response.reply(t('subject.does_not_exist', name: name)) unless Label.exists?(name)
+        l = Label.new(name)
+        l.wait_queue.delete(response.user.id)
+        response.reply(t('label.removed_from_queue', name: name))
+      end
+
       def list(response)
         username = response.match_data['username']
         user = Lita::User.fuzzy_find(username)
-        return response.reply('Unknown user') unless user
+        return response.reply(t('user.unknown')) unless user
         l = user_locks(user)
-        return response.reply('That user has no active locks') unless l.size > 0
+        return response.reply(t('user.no_active_locks')) unless l.size > 0
         composed = ''
         l.each do |label_name|
           composed += "Label: #{label_name}\n"
@@ -56,6 +74,35 @@ module Lita
         response.reply(composed)
       end
 
+      private
+
+      def status_label(name)
+        l = Label.new(name)
+        return unlocked(t('label.desc', name: name, state: l.state.value)) unless l.locked?
+        if l.wait_queue.count > 0
+          queue = []
+          l.wait_queue.each do |u|
+            usr = Lita::User.find_by_id(u)
+            queue.push(usr.name)
+          end
+          locked(t('label.desc_owner_queue', name: name,
+                                             state: l.state.value,
+                                             owner_name: l.owner.name,
+                                             time: l.held_for,
+                                             queue: queue.join(', ')))
+        else
+          locked(t('label.desc_owner', name: name,
+                                       state: l.state.value,
+                                       owner_name: l.owner.name,
+                                       time: l.held_for))
+        end
+      end
+
+      def status_resource(name)
+        r = Resource.new(name)
+        t('resource.desc', name: name, state: r.state.value)
+      end
+
       Lita.register_handler(LockerMisc)
     end
   end