lita-locker 0.4.0 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 03119612570e96f75bb028de84abf384232d3706
-  data.tar.gz: a05484fd65388045838e0bf6940162aff13ceb2f
+  metadata.gz: 228a4b3898980e9de630cee8152cd4ea8104c830
+  data.tar.gz: fd299284bef188f5d7fee52c79c925c91b979187
 SHA512:
-  metadata.gz: 27704990d5d11504024266de0c058758eda2375f882cffa78f2377afe07f5ccc2328ed871ba0b3c963bd82abe46597244a376110059e2e59e02bf09bf1b97673
-  data.tar.gz: b8a522feb8841916016981f8d81136ccd1eb51b619978f64d58ce3b23d0f498a6f0dfc35bfb1df2900816ccc7d2aeacd52439798f03d13a0c070e23b0ca90ec6
+  metadata.gz: 078690a522779d50e1f8f5f83d3635bf401d26027cd68496a29b2f4472af7c444367df91e5c368d1def23b02946ff4f30cef6c67d1743b90f7442ccd13d526bf
+  data.tar.gz: 05fa9b743fa6a22e6c68e44d6f445cf143cb345c91c09fdad7fb959effc79299c36f3e91721e0b8123ab9af969197ee8595f011135bac98a6e0538dd8b9d485f

data/.rubocop.yml

@@ -5,7 +5,7 @@ ClassLength:
   Max: 500
 
 CyclomaticComplexity:
-  Max: 10
+  Max: 8
 
 Documentation:
   Exclude:
@@ -17,3 +17,10 @@ FileName:
 
 MethodLength:
   Max: 200
+
+LineLength:
+  Max: 85
+
+GuardClause:
+  Exclude:
+    - lib/lita/handlers/locker.rb

data/README.md

@@ -31,17 +31,16 @@ if all of the resources it uses are available.
 ### Examples
 ```
 lock web                - Make something unavailable to others
-lock web 30m            - Make something unavailable to others for 30 minutes
 unlock web              - Make something available to others
-locker reserve web      - Make yourself the next owner of something after it is unlocked
-locker status           - Show what is and isn't available
+steal web               - Make yourself the owner of something locked by someone else
+locker status web       - Show the current state of web
 ```
 
 ### Locking, Unlocking, State
 ```
-lock <subject>         - A basic reservation, with no time limit.  <subject> can be a resource or a label.
-unlock <subject>       - Remove a reservation.  This can only be done by whomever made the request.
-unlock <subject> force - Force removal of a reservation.  This can be done by anyone.
+lock <label>         - A basic reservation, with no time limit. Can have # comments afterwards.
+unlock <label>       - Remove a reservation.  This can only be done by whomever made the request. Can have # comments afterwards.
+steal <label>        - Force removal of a reservation.  This can be done by anyone. Can have # comments afterwards.
 ```
 
 ### Time-based locking - Not implemented yet!

data/Rakefile

@@ -3,6 +3,6 @@ require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
 
 RSpec::Core::RakeTask.new(:spec)
-Rubocop::RakeTask.new(:rubocop)
+RuboCop::RakeTask.new(:rubocop)
 
 task default: [:spec, :rubocop]

data/TODO.md

@@ -0,0 +1,5 @@
+Things to do:
+
+* Better user management (meaning use the actual Lita user ID)
+* User mentions in responses (if possible)
+* Make emoji optional (since not all people use Hipchat)

data/lib/lita/handlers/locker.rb

@@ -4,63 +4,53 @@ module Lita
       http.get '/locker/label/:name', :http_label_show
       http.get '/locker/resource/:name', :http_resource_show
 
-      LABEL_REGEX    = /([\W\S_-]+)/
-      RESOURCE_REGEX = /([\.a-zA-Z0-9_-]+)/
+      LABEL_REGEX    = /([\.\w\s-]+)/
+      RESOURCE_REGEX = /([\.\w-]+)/
+      COMMENT_REGEX  = /(\s\#.+)?/
 
       route(
-        /^\(lock\)\s#{LABEL_REGEX}$/,
+        /^\(lock\)\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :lock
       )
 
       route(
-        /^\(unlock\)\s#{LABEL_REGEX}$/,
+        /^(?:\(unlock\)|\(release\))\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :unlock
       )
 
       route(
-        /^lock\s#{LABEL_REGEX}$/,
+        /^lock\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :lock,
         command: true,
-        help: {
-          t('help.lock_key') => t('help.lock_value')
-        }
+        help: { t('help.lock.syntax') => t('help.lock.desc') }
       )
 
-#      route(
-#        /^lock\s([a-zA-Z0-9_-]+)\s(\d+)(s|m|h)$/,
-#        :lock,
-#        command: true,
-#        help: {
-#          t('help.lock_time_key') => t('help.lock_time_value')
-#        }
-#      )
-
       route(
-        /^unlock\s#{LABEL_REGEX}$/,
+        /^unlock\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :unlock,
         command: true,
-        help: {
-          t('help.unlock_key') => t('help.unlock_value')
-        }
+        help: { t('help.unlock.syntax') => t('help.unlock.desc') }
       )
 
       route(
-        /^unlock\s#{LABEL_REGEX}\sforce$/,
-        :unlock_force,
+        /^steal\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
+        :steal,
         command: true,
-        help: {
-          t('help.unlock_force_key') => t('help.unlock_force_value')
-        }
+        help: { t('help.steal.syntax') => t('help.steal.desc') }
+      )
+
+      route(
+        /^locker\sstatus\s#{LABEL_REGEX}$/,
+        :status,
+        command: true,
+        help: { t('help.status.syntax') => t('help.status.desc') }
       )
 
       route(
         /^locker\sresource\slist$/,
         :resource_list,
         command: true,
-        help: {
-          t('help.resource_list_key') =>
-          t('help.resource_list_value')
-        }
+        help: { t('help.resource.list.syntax') => t('help.resource.list.desc') }
       )
 
       route(
@@ -69,8 +59,7 @@ module Lita
         command: true,
         restrict_to: [:locker_admins],
         help: {
-          t('help.resource_create_key') =>
-          t('help.resource_create_value')
+          t('help.resource.create.syntax') => t('help.resource.create.desc')
         }
       )
 
@@ -80,8 +69,7 @@ module Lita
         command: true,
         restrict_to: [:locker_admins],
         help: {
-          t('help.resource_delete_key') =>
-          t('help.resource_delete_value')
+          t('help.resource.delete.syntax') => t('help.resource.delete.desc')
         }
       )
 
@@ -89,178 +77,142 @@ module Lita
         /^locker\sresource\sshow\s#{RESOURCE_REGEX}$/,
         :resource_show,
         command: true,
-        help: {
-          t('help.resource_show_key') =>
-          t('help.resource_show_value')
-        }
+        help: { t('help.resource.show.syntax') => t('help.resource.show.desc') }
       )
 
       route(
         /^locker\slabel\slist$/,
         :label_list,
         command: true,
-        help: {
-          t('help.label_list_key') =>
-          t('help.label_list_value')
-        }
+        help: { t('help.label.list.syntax') => t('help.label.list.desc') }
       )
 
       route(
         /^locker\slabel\screate\s#{LABEL_REGEX}$/,
         :label_create,
         command: true,
-        help: {
-          t('help.label_create_key') =>
-          t('help.label_create_value')
-        }
+        help: { t('help.label.create.syntax') => t('help.label.create.desc') }
       )
 
       route(
         /^locker\slabel\sdelete\s#{LABEL_REGEX}$/,
         :label_delete,
         command: true,
-        help: {
-          t('help.label_delete_key') =>
-          t('help.label_delete_value')
-        }
+        help: { t('help.label.delete.syntax') => t('help.label.delete.desc') }
       )
 
       route(
         /^locker\slabel\sshow\s#{LABEL_REGEX}$/,
         :label_show,
         command: true,
-        help: {
-          t('help.label_show_key') =>
-          t('help.label_show_value')
-        }
+        help: { t('help.label.show.syntax') => t('help.label.show.desc') }
       )
 
       route(
         /^locker\slabel\sadd\s#{RESOURCE_REGEX}\sto\s#{LABEL_REGEX}$/,
         :label_add,
         command: true,
-        help: {
-          t('help.label_add_key') =>
-          t('help.label_add_value')
-        }
+        help: { t('help.label.add.syntax') => t('help.label.add.desc') }
       )
 
       route(
         /^locker\slabel\sremove\s#{RESOURCE_REGEX}\sfrom\s#{LABEL_REGEX}$/,
         :label_remove,
         command: true,
-        help: {
-          t('help.label_remove_key') =>
-          t('help.label_remove_value')
-        }
+        help: { t('help.label.remove.syntax') => t('help.label.remove.desc') }
       )
 
       def http_label_show(request, response)
         name = request.env['router.params'][:name]
         response.headers['Content-Type'] = 'application/json'
-        result = label(name)
-        response.write(result.to_json)
+        response.write(label(name).to_json)
       end
 
       def http_resource_show(request, response)
         name = request.env['router.params'][:name]
         response.headers['Content-Type'] = 'application/json'
-        result = resource(name)
-        response.write(result.to_json)
+        response.write(resource(name).to_json)
       end
 
       def lock(response)
         name = response.matches[0][0]
-        timeamt = response.matches[0][1]
-        timeunit = response.matches[0][2]
-        case timeunit
-        when 's'
-          time_until = Time.now.utc + timeamt.to_i
-        when 'm'
-          time_until = Time.now.utc + (timeamt.to_i * 60)
-        when 'h'
-          time_until = Time.now.utc + (timeamt.to_i * 3600)
-        else
-          time_until = nil
-        end
 
-        if resource_exists?(name)
-          if lock_resource!(name, response.user, time_until)
-            response.reply(t('resource.lock', name: name))
-          else
-            response.reply(t('resource.is_locked', name: name))
-          end
-        elsif label_exists?(name)
+        if label_exists?(name)
           m = label_membership(name)
           if m.count > 0
-            if lock_label!(name, response.user, time_until)
-              response.reply(t('label.lock', name: name))
+            if lock_label!(name, response.user, nil)
+              response.reply('(successful) ' + t('label.lock', name: name))
             else
-              response.reply(t('label.unable_to_lock', name: name))
+              l = label(name)
+              if l['state'] == 'locked'
+                response.reply('(failed) ' + t('label.owned',
+                                               name: name,
+                                               owner_name: l['owner_name'],
+                                               owner_mention: l['owner_mention']))
+              else
+                response.reply('(failed) ' + t('label.dependency'))
+              end
             end
           else
-            response.reply(t('label.no_resources', name: name))
+            response.reply('(failed) ' + t('label.no_resources', name: name))
           end
         else
-          response.reply(t('subject.does_not_exist', name: name))
+          response.reply('(failed) ' + t('label.does_not_exist', name: name))
         end
       end
 
       def unlock(response)
         name = response.matches[0][0]
-        if resource_exists?(name)
-          res = resource(name)
-          if res['state'] == 'unlocked'
-            response.reply(t('resource.is_unlocked', name: name))
-          else
-            # FIXME: NOT SECURE
-            if response.user.name == res['owner']
-              unlock_resource!(name)
-              response.reply(t('resource.unlock', name: name))
-              # FIXME: Handle the case where things can't be unlocked?
-            else
-              response.reply(t('resource.owned', name: name,
-                                                 owner: res['owner']))
-            end
-          end
-        elsif label_exists?(name)
+        if label_exists?(name)
           l = label(name)
           if l['state'] == 'unlocked'
-            response.reply(t('label.is_unlocked', name: name))
+            response.reply('(successful) ' + t('label.is_unlocked',
+                                               name: name))
           else
-            # FIXME: NOT SECURE
-            if response.user.name == l['owner']
+            if response.user.id == l['owner_id']
               unlock_label!(name)
-              response.reply(t('label.unlock', name: name))
-              # FIXME: Handle the case where things can't be unlocked?
+              response.reply('(successful) ' + t('label.unlock', name: name))
             else
-              response.reply(t('label.owned', name: name,
-                                              owner: l['owner']))
+              response.reply('(failed) ' + t('label.owned',
+                                             name: name,
+                                             owner_name: l['owner_name'],
+                                             owner_mention: l['owner_mention']))
             end
           end
         else
-          response.reply(t('subject.does_not_exist', name: name))
+          response.reply('(failed) ' + t('subject.does_not_exist', name: name))
         end
       end
 
-      def unlock_force(response)
+      def steal(response)
         name = response.matches[0][0]
-        if resource_exists?(name)
-          unlock_resource!(name)
-          response.reply(t('resource.unlock', name: name))
-          # FIXME: Handle the case where things can't be unlocked?
-        elsif label_exists?(name)
+        if label_exists?(name)
           unlock_label!(name)
-          response.reply(t('label.unlock', name: name))
+          response.reply('(successful) ' + t('label.unlock', name: name))
           # FIXME: Handle the case where things can't be unlocked?
+        else
+          response.reply('(failed) ' + t('subject.does_not_exist', name: name))
+        end
+      end
+
+      def status(response)
+        name = response.matches[0][0]
+        if label_exists?(name)
+          l = label(name)
+          response.reply(t('label.desc', name: name, state: l['state']))
+        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))
         end
       end
 
       def label_list(response)
-        labels.each do |l|
-          response.reply(t('label.desc', name: l.sub('label_', '')))
+        labels.each do |n|
+          name = n.sub('label_', '')
+          l = label(name)
+          response.reply(t('label.desc', name: name, state: l['state']))
         end
       end
 
@@ -336,11 +288,13 @@ module Lita
       end
 
       def resource_list(response)
+        output = ''
         resources.each do |r|
           r_name = r.sub('resource_', '')
           res = resource(r_name)
-          response.reply(t('resource.desc', name: r_name, state: res['state']))
+          output += t('resource.desc', name: r_name, state: res['state'])
         end
+        response.reply(output)
       end
 
       def resource_create(response)
@@ -425,9 +379,10 @@ module Lita
           value = redis.hget(resource_key, 'state')
           if value == 'unlocked'
             # FIXME: Race condition!
-            # FIXME: Store something better than name
             redis.hset(resource_key, 'state', 'locked')
-            redis.hset(resource_key, 'owner', owner.name)
+            redis.hset(resource_key, 'owner_id', owner.id)
+            redis.hset(resource_key, 'owner_name', owner.name)
+            redis.hset(resource_key, 'owner_mention', owner.mention_name)
             redis.hset(resource_key, 'until', time_until)
             true
           else
@@ -443,15 +398,12 @@ module Lita
           key = "label_#{name}"
           members = label_membership(name)
           members.each do |m|
-            r = resource(m)
-            return false if r['state'] == 'locked'
-          end
-          # FIXME: No, really, race condition.
-          members.each do |m|
-            lock_resource!(m, owner, time_until)
+            return false unless lock_resource!(m, owner, time_until)
           end
           redis.hset(key, 'state', 'locked')
-          redis.hset(key, 'owner', owner.name)
+          redis.hset(key, 'owner_id', owner.id)
+          redis.hset(key, 'owner_name', owner.name)
+          redis.hset(key, 'owner_mention', owner.mention_name)
           redis.hset(key, 'until', time_until)
           true
         else
@@ -461,10 +413,11 @@ module Lita
 
       def unlock_resource!(name)
         if resource_exists?(name)
-          # FIXME: Tracking here?
           key = "resource_#{name}"
           redis.hset(key, 'state', 'unlocked')
-          redis.hset(key, 'owner', '')
+          redis.hset(key, 'owner_name', '')
+          redis.hset(key, 'owner_mention', '')
+          redis.hset(key, 'owner_id', '')
         else
           false
         end
@@ -478,7 +431,9 @@ module Lita
             unlock_resource!(m)
           end
           redis.hset(key, 'state', 'unlocked')
-          redis.hset(key, 'owner', '')
+          redis.hset(key, 'owner_name', '')
+          redis.hset(key, 'owner_mention', '')
+          redis.hset(key, 'owner_id', '')
           true
         else
           false

data/lita-locker.gemspec

@@ -1,10 +1,10 @@
 Gem::Specification.new do |spec|
   spec.name          = 'lita-locker'
-  spec.version       = '0.4.0'
+  spec.version       = '0.5.0'
   spec.authors       = ['Eric Sigler']
   spec.email         = ['me@esigler.com']
-  spec.description   = %q("lock" and "unlock" arbitrary subjects)
-  spec.summary       = %q("lock" and "unlock" arbitrary subjects)
+  spec.description   = '"lock" and "unlock" arbitrary subjects'
+  spec.summary       = '"lock" and "unlock" arbitrary subjects'
   spec.homepage      = 'https://github.com/esigler/lita-locker'
   spec.license       = 'MIT'
   spec.metadata      = { 'lita_plugin_type' => 'handler' }

data/locales/en.yml

@@ -3,32 +3,50 @@ en:
     handlers:
       locker:
         help:
-          lock_key: lock <subject>
-          lock_value: Make something unavailable to others
-          unlock_key: unlock <subject>
-          unlock_value: Make something available to others
-          unlock_force_key: unlock <subject> force
-          unlock_force_value: Force removal of a reservation.
-          resource_list_key: locker resource list
-          resource_list_value: List all resources
-          resource_create_key: locker resource create <name>
-          resource_create_value: Create a resource with <name>
-          resource_delete_key: locker resource delete <name>
-          resource_delete_value: Delete the resource with <name>
-          resource_show_key: locker resource show <name>
-          resource_show_value: Show the state of <name>
-          label_list_key: locker label list
-          label_list_value: List all labels
-          label_create_key: locker label create <name>
-          label_create_value: Create a label with <name>
-          label_delete_key: locker label delete <name>
-          label_delete_value: Delete the label with <name>
-          label_show_key: locker label show <name>
-          label_show_value: Show all resources for <name>
-          label_add_key: locker label add <resource> to <name>
-          label_add_value: Adds <resource> to the list of things to lock/unlock for <name>
-          label_remove_key: locker label remove <resource> from <name>
-          label_remove_value: Removes <resource> from <name>
+          lock:
+            syntax: lock <subject>
+            desc: Make something unavailable to others. Can have # comments afterwards.
+          unlock:
+            syntax: unlock <subject>
+            desc: Make something available to others. Can have # comments afterwards.
+          steal:
+            syntax: steal <subject>
+            desc: Force removal of a reservation. Can have # comments afterwards.
+          status:
+            syntax: locker status <label or resource>
+            desc: Show the current state of <label or resource>
+          resource:
+            list:
+              syntax: locker resource list
+              desc: List all resources
+            create:
+              syntax: locker resource create <name>
+              desc: Create a resource with <name>
+            delete:
+              syntax: locker resource delete <name>
+              desc: Delete the resource with <name>
+            show:
+              syntax: locker resource show <name>
+              desc: Show the state of <name>
+          label:
+            list:
+              syntax: locker label list
+              desc: List all labels
+            create:
+              syntax: locker label create <name>
+              desc: Create a label with <name>
+            delete:
+              syntax: locker label delete <name>
+              desc: Delete the label with <name>
+            show:
+              syntax: locker label show <name>
+              desc: Show all resources for <name>
+            add:
+              syntax: locker label add <resource> to <name>
+              desc: Adds <resource> to the list of things to lock/unlock for <name>
+            remove:
+              syntax: locker label remove <resource> from <name>
+              desc: Removes <resource> from <name>
         resource:
           created: "Resource %{name} created"
           desc: "Resource: %{name}, state: %{state}"
@@ -39,23 +57,24 @@ en:
           is_locked: "%{name} is locked"
           unlock: "%{name} unlocked"
           is_unlocked: "%{name} is unlocked"
-          owned: "%{name} is locked by %{owner}"
+          owned: "%{name} is locked by %{owner_name} %{owner_mention}"
         subject:
-          does_not_exist: "%{name} does not exist"
+          does_not_exist: "Sorry, that does not exist"
         label:
           unlock: "%{name} unlocked"
-          owned: "%{name} is locked by %{owner}"
+          owned: "%{name} is locked by %{owner_name} %{owner_mention}"
           is_unlocked: "%{name} is unlocked"
           unable_to_lock: "%{name} unable to be locked"
           lock: "%{name} locked"
-          desc: "Label: %{name}"
+          desc: "Label: %{name}, state: %{state}"
           created: "Label %{name} created"
           exists: "%{name} already exists"
           deleted: "Label %{name} deleted"
-          does_not_exist: "Label %{name} does not exist"
+          does_not_exist: "Label %{name} does not exist.  To create it: \"!locker label create %{name}\""
           has_no_resources: "Label %{name} has no resources"
           resource_added: "Resource %{resource} has been added to %{label}"
           resource_removed: "Resource %{resource} has been removed from %{label}"
           resources: "Label %{name} has: %{resources}"
           does_not_have_resource: "Label %{label} does not have Resource %{resource}"
           no_resources: "%{name} has no resources, so it cannot be locked"
+          dependency: 'Label unable to be locked, blocked on a dependency'

data/spec/lita/handlers/locker_spec.rb

@@ -1,35 +1,51 @@
 require 'spec_helper'
 
 describe Lita::Handlers::Locker, lita_handler: true do
-  it { routes('(lock) foobar').to(:lock) }
-  it { routes('(unlock) foobar').to(:unlock) }
+  label_examples = ['foobar', 'foo bar', 'foo-bar', 'foo_bar']
+  resource_examples = ['foobar', 'foo.bar', 'foo-bar', 'foo_bar']
+
+  label_examples.each do |l|
+    it { routes("(lock) #{l}").to(:lock) }
+    it { routes("(unlock) #{l}").to(:unlock) }
+    it { routes("(release) #{l}").to(:unlock) }
+
+    it { routes("(lock) #{l} #this is a comment").to(:lock) }
+    it { routes("(unlock) #{l} #this is a comment").to(:unlock) }
+    it { routes("(release) #{l} #this is a comment").to(:unlock) }
+
+    it { routes_command("lock #{l}").to(:lock) }
+    it { routes_command("lock #{l} #this is a comment").to(:lock) }
+    it { routes_command("unlock #{l}").to(:unlock) }
+    it { routes_command("unlock #{l} #this is a comment").to(:unlock) }
+    it { routes_command("steal #{l}").to(:steal) }
+    it { routes_command("steal #{l} #this is a comment").to(:steal) }
+  end
 
-  it { routes_command('lock foobar').to(:lock) }
-  it { routes_command('lock foo bar').to(:lock) }
-  it { routes_command('lock foo-bar').to(:lock) }
-  it { routes_command('lock foo_bar').to(:lock) }
-#  it { routes_command('lock foobar 30m').to(:lock) }
+  label_examples.each do |l|
+    it { routes_command("locker status #{l}").to(:status) }
+  end
 
-  it { routes_command('unlock foobar').to(:unlock) }
-  it { routes_command('unlock foo bar').to(:unlock) }
-  it { routes_command('unlock foo-bar').to(:unlock) }
-  it { routes_command('unlock foo_bar').to(:unlock) }
-  it { routes_command('unlock foobar force').to(:unlock_force) }
+  resource_examples.each do |r|
+    it { routes_command("locker status #{r}").to(:status) }
+  end
 
   it { routes_command('locker resource list').to(:resource_list) }
-  it { routes_command('locker resource create foobar').to(:resource_create) }
-  it { routes_command('locker resource create foo.bar').to(:resource_create) }
-  it { routes_command('locker resource create foo-bar').to(:resource_create) }
-  it { routes_command('locker resource create foo_bar').to(:resource_create) }
-  it { routes_command('locker resource delete foobar').to(:resource_delete) }
-  it { routes_command('locker resource show foobar').to(:resource_show) }
+
+  resource_examples.each do |r|
+    it { routes_command("locker resource create #{r}").to(:resource_create) }
+    it { routes_command("locker resource delete #{r}").to(:resource_delete) }
+    it { routes_command("locker resource show #{r}").to(:resource_show) }
+  end
 
   it { routes_command('locker label list').to(:label_list) }
-  it { routes_command('locker label create foobar').to(:label_create) }
-  it { routes_command('locker label delete foobar').to(:label_delete) }
-  it { routes_command('locker label show foobar').to(:label_show) }
-  it { routes_command('locker label add foo to bar').to(:label_add) }
-  it { routes_command('locker label remove foo from bar').to(:label_remove) }
+
+  label_examples.each do |l|
+    it { routes_command("locker label create #{l}").to(:label_create) }
+    it { routes_command("locker label delete #{l}").to(:label_delete) }
+    it { routes_command("locker label show #{l}").to(:label_show) }
+    it { routes_command("locker label add resource to #{l}").to(:label_add) }
+    it { routes_command("locker label remove resource from #{l}").to(:label_remove) }
+  end
 
   it { routes_http(:get, '/locker/label/foobar').to(:http_label_show) }
   it { routes_http(:get, '/locker/resource/foobar').to(:http_resource_show) }
@@ -41,19 +57,21 @@ describe Lita::Handlers::Locker, lita_handler: true do
     ).and_return(true)
   end
 
-  describe '#lock' do
-    it 'locks a resource when it is available' do
-      send_command('locker resource create foobar')
-      send_command('lock foobar')
-      expect(replies.last).to eq('foobar locked')
-    end
+  let(:alice) do
+    Lita::User.create('9001@hipchat', name: 'Alice', mention_name: '@alice')
+  end
 
+  let(:bob) do
+    Lita::User.create('9002@hipchat', name: 'Bob', mention_name: '@bob')
+  end
+
+  describe '#lock' do
     it 'locks a label when it is available and has resources' do
       send_command('locker resource create foobar')
       send_command('locker label create bazbat')
       send_command('locker label add foobar to bazbat')
-      send_command('lock bazbat')
-      expect(replies.last).to eq('bazbat locked')
+      send_command('lock bazbat # with a comment')
+      expect(replies.last).to eq('(successful) bazbat locked')
       send_command('locker resource show foobar')
       expect(replies.last).to eq('Resource: foobar, state: locked')
     end
@@ -61,87 +79,69 @@ describe Lita::Handlers::Locker, lita_handler: true do
     it 'shows a warning when a label has no resources' do
       send_command('locker label create foobar')
       send_command('lock foobar')
-      expect(replies.last).to eq('foobar has no resources, ' \
+      expect(replies.last).to eq('(failed) foobar has no resources, ' \
                                  'so it cannot be locked')
     end
 
-    it 'shows a warning when a resource is unavailable' do
-      send_command('locker resource create foobar')
-      send_command('lock foobar')
-      send_command('lock foobar')
-      expect(replies.last).to eq('foobar is locked')
-    end
-
     it 'shows a warning when a label is unavailable' do
+      send_command('locker resource create r1')
+      send_command('locker label create l1')
+      send_command('locker label create l2')
+      send_command('locker label add r1 to l1')
+      send_command('locker label add r1 to l2')
+      send_command('lock l1', as: alice)
+      send_command('lock l2', as: alice)
+      expect(replies.last).to eq('(failed) Label unable to be locked, ' \
+                                 'blocked on a dependency')
+    end
+
+    it 'shows a warning when a label is taken by someone else' do
       send_command('locker resource create foobar')
       send_command('locker label create bazbat')
       send_command('locker label add foobar to bazbat')
-      send_command('lock foobar')
-      send_command('lock bazbat')
-      expect(replies.last).to eq('bazbat unable to be locked')
+      send_command('lock bazbat', as: alice)
+      send_command('lock bazbat', as: bob)
+      expect(replies.last).to eq('(failed) bazbat is locked by Alice @alice')
     end
 
-    it 'shows an error when a <subject> does not exist' do
+    it 'shows an error when a label does not exist' do
       send_command('lock foobar')
-      expect(replies.last).to eq('foobar does not exist')
-    end
-
-#    it 'locks a resource when it is available for a period of time' do
-#      send_command('locker resource create foobar')
-#      send_command('lock foobar 17m')
-#      expect(replies.last).to eq('foobar locked for 17 minutes')
-#      send_command('locker resource show foobar')
-#      expect(replies.last).to eq('Resource: foobar, state: locked')
-#      send_command('unlock foobar')
-#      send_command('lock foobar 12s')
-#      expect(replies.last).to eq('foobar locked for 17 seconds')
-#      send_command('unlock foobar')
-#      send_command('lock foobar 14h')
-#      expect(replies.last).to eq('foobar locked for 14 hours')
-#    end
+      expect(replies.last).to eq('(failed) Label foobar does not exist.  To ' \
+                                 'create it: "!locker label create foobar"')
+    end
+
+    # it 'locks a resource when it is available for a period of time' do
+    #   send_command('locker resource create foobar')
+    #   send_command('lock foobar 17m')
+    #   expect(replies.last).to eq('foobar locked for 17 minutes')
+    #   send_command('locker resource show foobar')
+    #   expect(replies.last).to eq('Resource: foobar, state: locked')
+    #   send_command('unlock foobar')
+    #   send_command('lock foobar 12s')
+    #   expect(replies.last).to eq('foobar locked for 17 seconds')
+    #   send_command('unlock foobar')
+    #   send_command('lock foobar 14h')
+    #   expect(replies.last).to eq('foobar locked for 14 hours')
+    # end
   end
 
   describe '#unlock' do
-    it 'unlocks a resource when it is available' do
-      send_command('locker resource create foobar')
-      send_command('lock foobar')
-      send_command('unlock foobar')
-      expect(replies.last).to eq('foobar unlocked')
-    end
-
-    it 'does not unlock a resource when someone else locked it' do
-      alice = Lita::User.create(1, name: 'Alice')
-      bob = Lita::User.create(2, name: 'Bob')
-      send_command('locker resource create foobar')
-      send_command('lock foobar', as: alice)
-      send_command('unlock foobar', as: bob)
-      expect(replies.last).to eq('foobar is locked by Alice')
-    end
-
     it 'unlocks a label when it is available' do
       send_command('locker resource create foobar')
       send_command('locker label create bazbat')
       send_command('locker label add foobar to bazbat')
       send_command('lock bazbat')
-      send_command('unlock bazbat')
-      expect(replies.last).to eq('bazbat unlocked')
+      send_command('unlock bazbat # with a comment')
+      expect(replies.last).to eq('(successful) bazbat unlocked')
     end
 
     it 'does not unlock a label when someone else locked it' do
-      alice = Lita::User.create(1, name: 'Alice')
-      bob = Lita::User.create(2, name: 'Bob')
       send_command('locker resource create foobar')
       send_command('locker label create bazbat')
       send_command('locker label add foobar to bazbat')
       send_command('lock bazbat', as: alice)
       send_command('unlock bazbat', as: bob)
-      expect(replies.last).to eq('bazbat is locked by Alice')
-    end
-
-    it 'shows a warning when a resource is already unlocked' do
-      send_command('locker resource create foobar')
-      send_command('unlock foobar')
-      expect(replies.last).to eq('foobar is unlocked')
+      expect(replies.last).to eq('(failed) bazbat is locked by Alice @alice')
     end
 
     it 'shows a warning when a label is already unlocked' do
@@ -150,39 +150,57 @@ describe Lita::Handlers::Locker, lita_handler: true do
       send_command('locker label add foobar to bazbat')
       send_command('unlock bazbat')
       send_command('unlock bazbat')
-      expect(replies.last).to eq('bazbat is unlocked')
+      expect(replies.last).to eq('(successful) bazbat is unlocked')
     end
 
     it 'shows an error when a <subject> does not exist' do
       send_command('unlock foobar')
-      expect(replies.last).to eq('foobar does not exist')
+      expect(replies.last).to eq('(failed) Sorry, that does not exist')
     end
   end
 
-  describe '#unlock_force' do
-    it 'unlocks a resource from someone else when it is available' do
-      alice = Lita::User.create(1, name: 'Alice')
-      bob = Lita::User.create(2, name: 'Bob')
-      send_command('locker resource create foobar')
-      send_command('lock foobar', as: alice)
-      send_command('unlock foobar force', as: bob)
-      expect(replies.last).to eq('foobar unlocked')
-    end
-
+  describe '#steal' do
     it 'unlocks a label from someone else when it is available' do
-      alice = Lita::User.create(1, name: 'Alice')
-      bob = Lita::User.create(2, name: 'Bob')
       send_command('locker resource create foobar')
       send_command('locker label create bazbat')
       send_command('locker label add foobar to bazbat')
       send_command('lock bazbat', as: alice)
-      send_command('unlock bazbat force', as: bob)
-      expect(replies.last).to eq('bazbat unlocked')
+      send_command('steal bazbat # with a comment', as: bob)
+      expect(replies.last).to eq('(successful) bazbat unlocked')
     end
 
     it 'shows an error when a <subject> does not exist' do
-      send_command('unlock foobar force')
-      expect(replies.last).to eq('foobar does not exist')
+      send_command('steal foobar')
+      expect(replies.last).to eq('(failed) Sorry, that does not exist')
+    end
+  end
+
+  describe '#status' do
+    it 'shows the status of a label' do
+      send_command('locker resource create bar')
+      send_command('locker label create foo')
+      send_command('locker label add bar to foo')
+      send_command('locker status foo')
+      expect(replies.last).to eq('Label: foo, state: unlocked')
+      send_command('lock foo')
+      send_command('locker status foo')
+      expect(replies.last).to eq('Label: foo, state: locked')
+    end
+
+    it 'shows the status of a resource' do
+      send_command('locker resource create bar')
+      send_command('locker label create foo')
+      send_command('locker label add bar to foo')
+      send_command('locker status bar')
+      expect(replies.last).to eq('Resource: bar, state: unlocked')
+      send_command('lock foo')
+      send_command('locker status bar')
+      expect(replies.last).to eq('Resource: bar, state: locked')
+    end
+
+    it 'shows an error if nothing exists with that name' do
+      send_command('locker status foo')
+      expect(replies.last).to eq('Sorry, that does not exist')
     end
   end
 
@@ -191,8 +209,8 @@ describe Lita::Handlers::Locker, lita_handler: true do
       send_command('locker label create foobar')
       send_command('locker label create bazbat')
       send_command('locker label list')
-      expect(replies.include?('Label: foobar')).to eq(true)
-      expect(replies.include?('Label: bazbat')).to eq(true)
+      expect(replies.include?('Label: foobar, state: unlocked')).to eq(true)
+      expect(replies.include?('Label: bazbat, state: unlocked')).to eq(true)
     end
   end
 
@@ -224,7 +242,8 @@ describe Lita::Handlers::Locker, lita_handler: true do
 
     it 'shows a warning when <name> does not exist' do
       send_command('locker label delete foobar')
-      expect(replies.last).to eq('Label foobar does not exist')
+      expect(replies.last).to eq('Label foobar does not exist.  To create ' \
+                                 'it: "!locker label create foobar"')
     end
   end
 
@@ -245,7 +264,8 @@ describe Lita::Handlers::Locker, lita_handler: true do
 
     it 'shows an error if the label does not exist' do
       send_command('locker label show foobar')
-      expect(replies.last).to eq('Label foobar does not exist')
+      expect(replies.last).to eq('Label foobar does not exist.  To create ' \
+                                 'it: "!locker label create foobar"')
     end
   end
 
@@ -266,12 +286,13 @@ describe Lita::Handlers::Locker, lita_handler: true do
       send_command('locker label add foo to bar')
       send_command('locker label add baz to bar')
       send_command('locker label show bar')
-      expect(replies.last).to eq('Label bar has: baz, foo')
+      expect(replies.last).to eq('Label bar has: foo, baz')
     end
 
     it 'shows an error if the label does not exist' do
       send_command('locker label add foo to bar')
-      expect(replies.last).to eq('Label bar does not exist')
+      expect(replies.last).to eq('Label bar does not exist.  To create ' \
+                                 'it: "!locker label create bar"')
     end
 
     it 'shows an error if the resource does not exist' do
@@ -300,7 +321,8 @@ describe Lita::Handlers::Locker, lita_handler: true do
 
     it 'shows an error if the label does not exist' do
       send_command('locker label add foo to bar')
-      expect(replies.last).to eq('Label bar does not exist')
+      expect(replies.last).to eq('Label bar does not exist.  To create ' \
+                                 'it: "!locker label create bar"')
     end
 
     it 'shows an error if the resource does not exist' do
@@ -315,8 +337,8 @@ describe Lita::Handlers::Locker, lita_handler: true do
       send_command('locker resource create foobar')
       send_command('locker resource create bazbat')
       send_command('locker resource list')
-      expect(replies.include?('Resource: foobar, state: unlocked')).to eq(true)
-      expect(replies.include?('Resource: bazbat, state: unlocked')).to eq(true)
+      expect(replies.last).to match(/Resource: foobar, state: unlocked/)
+      expect(replies.last).to match(/Resource: bazbat, state: unlocked/)
     end
   end
 
@@ -357,9 +379,6 @@ describe Lita::Handlers::Locker, lita_handler: true do
       send_command('locker resource create foobar')
       send_command('locker resource show foobar')
       expect(replies.last).to eq('Resource: foobar, state: unlocked')
-      send_command('lock foobar')
-      send_command('locker resource show foobar')
-      expect(replies.last).to eq('Resource: foobar, state: locked')
     end
 
     it 'shows a warning when <name> does not exist' do

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: lita-locker
 version: !ruby/object:Gem::Version
-  version: 0.4.0
+  version: 0.5.0
 platform: ruby
 authors:
 - Eric Sigler
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-16 00:00:00.000000000 Z
+date: 2014-07-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lita
@@ -122,6 +122,7 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- TODO.md
 - lib/lita-locker.rb
 - lib/lita/handlers/locker.rb
 - lita-locker.gemspec