lita-locker 0.3.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e5c32b7506039ce73526e9483adfd4243e1aa36d
+  data.tar.gz: 745a609c8595fe3bd6cb8caab9de837b439f9049
+SHA512:
+  metadata.gz: 3849f4ad7eec61bc12027688a35ff8002cac08dbcc8b0f0e478b7b3a31ea4f3e928ab33414c2e69fa28687dd005fb0cc0e9c3d7f986fb1b4a26de6fa871fcd84
+  data.tar.gz: 8408eff2c472f5d9f9141d91bed7bf6fa2a3c8e6d5a80e54d38a3eec20bba820d4d81ce78ea68fd2cbc886f7e3066b795e495fc733c9e5e14c934a39d1323ca0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rubocop.yml

@@ -0,0 +1,19 @@
+BlockNesting:
+  Max: 5
+
+ClassLength:
+  Max: 500
+
+CyclomaticComplexity:
+  Max: 10
+
+Documentation:
+  Exclude:
+    - lib/lita/handlers/locker.rb
+
+FileName:
+  Exclude:
+    - lib/lita-locker.rb
+
+MethodLength:
+  Max: 200

data/.travis.yml

@@ -0,0 +1,8 @@
+language: ruby
+rvm:
+  - 2.0.0
+script: bundle exec rake
+before_install:
+  - gem update --system
+services:
+  - redis-server

data/Gemfile

@@ -0,0 +1,3 @@
+source "https://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2014 Eric Sigler
+
+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,84 @@
+# lita-locker
+
+[![Build Status](https://img.shields.io/travis/esigler/lita-locker/master.svg)](https://travis-ci.org/esigler/lita-locker)
+[![MIT License](https://img.shields.io/badge/license-MIT-brightgreen.svg)](https://tldrlegal.com/license/mit-license)
+[![RubyGems :: RMuh Gem Version](http://img.shields.io/gem/v/lita-locker.svg)](https://rubygems.org/gems/lita-locker)
+[![Coveralls Coverage](https://img.shields.io/coveralls/esigler/lita-locker/master.svg)](https://coveralls.io/r/esigler/lita-locker)
+[![Code Climate](https://img.shields.io/codeclimate/github/esigler/lita-locker.svg)](https://codeclimate.com/github/esigler/lita-locker)
+[![Gemnasium](https://img.shields.io/gemnasium/esigler/lita-locker.svg)](https://gemnasium.com/esigler/lita-locker)
+
+Locking, unlocking shared resource handler for [lita.io](https://github.com/jimmycuadra/lita).
+
+## Installation
+
+Add lita-locker to your Lita instance's Gemfile:
+
+``` ruby
+gem "lita-locker"
+```
+
+## Configuration
+
+None
+
+## Usage
+
+lita-locker allows you to define resources (such as a server, or Git repo),
+and labels (such as "production").  Labels can have multiple resources, and
+resources can be referenced by multiple labels.  A label can only be locked
+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
+```
+
+### 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.
+```
+
+### Time-based locking - Not implemented yet!
+```
+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>
+```
+
+### Labels
+```
+locker label list                          - List all labels
+locker label create <name>                 - Create a label with <name>.  <name> must be A-Z, a-z, 0-9, no spaces or punctuation.
+locker label delete <name>                 - Delete the label with <name>.  Clears all locks associated.
+locker label add <resource> to <name>      - Adds <resource> to the list of things to lock/unlock for <name>
+locker label remove <resource> from <name> - Removes <resource> from <name>
+locker label show <name>                   - Show all resources for <name>
+```
+
+### Resources
+```
+locker resource list          - List all resources
+locker resource create <name> - Create a resource with <name>.  <name> must be A-Z, a-z, 0-9, no spaces or punctuation.
+locker resource delete <name> - Delete the resource with <name>.  Clears all locks associated.
+locker resource show <name>   - Show the state of <name>
+```
+
+### HTTP access
+```
+curl http://lita.example.com/locker/label/<name>    - Get current <name> status
+curl http://lita.example.com/locker/resource/<name> - Get current <name> status
+```
+
+## License
+
+[MIT](http://opensource.org/licenses/MIT)

data/Rakefile

@@ -0,0 +1,8 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+require 'rubocop/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+Rubocop::RakeTask.new(:rubocop)
+
+task default: [:spec, :rubocop]

data/lib/lita-locker.rb

@@ -0,0 +1,9 @@
+require 'lita'
+
+Lita.load_locales Dir[File.expand_path(
+  File.join('..', '..', 'locales', '*.yml'), __FILE__
+)]
+
+require 'JSON'
+
+require 'lita/handlers/locker'

data/lib/lita/handlers/locker.rb

@@ -0,0 +1,502 @@
+module Lita
+  module Handlers
+    class Locker < Handler
+      http.get '/locker/label/:name', :http_label_show
+      http.get '/locker/resource/:name', :http_resource_show
+
+#      route(
+#        /^\(lock\)\s([a-zA-Z0-9_-]+)$/,
+#        :lock
+#      )
+
+#      route(
+#        /^\(unlock\)\s([a-zA-Z0-9_-]+)$/,
+#        :unlock
+#      )
+
+      route(
+        /^lock\s([a-zA-Z0-9_-]+)$/,
+        :lock,
+        command: true,
+        help: {
+          t('help.lock_key') => t('help.lock_value')
+        }
+      )
+
+#      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([a-zA-Z0-9_-]+)$/,
+        :unlock,
+        command: true,
+        help: {
+          t('help.unlock_key') => t('help.unlock_value')
+        }
+      )
+
+      route(
+        /^unlock\s([a-zA-Z0-9_-]+)\sforce$/,
+        :unlock_force,
+        command: true,
+        help: {
+          t('help.unlock_force_key') => t('help.unlock_force_value')
+        }
+      )
+
+      route(
+        /^locker\sresource\slist$/,
+        :resource_list,
+        command: true,
+        help: {
+          t('help.resource_list_key') =>
+          t('help.resource_list_value')
+        }
+      )
+
+      route(
+        /^locker\sresource\screate\s([a-zA-Z0-9_-]+)$/,
+        :resource_create,
+        command: true,
+        help: {
+          t('help.resource_create_key') =>
+          t('help.resource_create_value')
+        }
+      )
+
+      route(
+        /^locker\sresource\sdelete\s([a-zA-Z0-9_-]+)$/,
+        :resource_delete,
+        command: true,
+        help: {
+          t('help.resource_delete_key') =>
+          t('help.resource_delete_value')
+        }
+      )
+
+      route(
+        /^locker\sresource\sshow\s([a-zA-Z0-9_-]+)$/,
+        :resource_show,
+        command: true,
+        help: {
+          t('help.resource_show_key') =>
+          t('help.resource_show_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\slist$/,
+        :label_list,
+        command: true,
+        help: {
+          t('help.label_list_key') =>
+          t('help.label_list_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\screate\s([a-zA-Z0-9_-]+)$/,
+        :label_create,
+        command: true,
+        help: {
+          t('help.label_create_key') =>
+          t('help.label_create_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\sdelete\s([a-zA-Z0-9_-]+)$/,
+        :label_delete,
+        command: true,
+        help: {
+          t('help.label_delete_key') =>
+          t('help.label_delete_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\sshow\s([a-zA-Z0-9_-]+)$/,
+        :label_show,
+        command: true,
+        help: {
+          t('help.label_show_key') =>
+          t('help.label_show_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\sadd\s([a-zA-Z0-9_-]+)\sto\s([a-zA-Z0-9_-]+)$/,
+        :label_add,
+        command: true,
+        help: {
+          t('help.label_add_key') =>
+          t('help.label_add_value')
+        }
+      )
+
+      route(
+        /^locker\slabel\sremove\s([a-zA-Z0-9_-]+)\sfrom\s([a-zA-Z0-9_-]+)$/,
+        :label_remove,
+        command: true,
+        help: {
+          t('help.label_remove_key') =>
+          t('help.label_remove_value')
+        }
+      )
+
+      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)
+      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)
+      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)
+          m = label_membership(name)
+          if m.count > 0
+            if lock_label!(name, response.user, time_until)
+              response.reply(t('label.lock', name: name))
+            else
+              response.reply(t('label.unable_to_lock', name: name))
+            end
+          else
+            response.reply(t('label.no_resources', name: name))
+          end
+        else
+          response.reply(t('subject.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)
+          l = label(name)
+          if l['state'] == 'unlocked'
+            response.reply(t('label.is_unlocked', name: name))
+          else
+            # FIXME: NOT SECURE
+            if response.user.name == l['owner']
+              unlock_label!(name)
+              response.reply(t('label.unlock', name: name))
+              # FIXME: Handle the case where things can't be unlocked?
+            else
+              response.reply(t('label.owned', name: name,
+                                              owner: l['owner']))
+            end
+          end
+        else
+          response.reply(t('subject.does_not_exist', name: name))
+        end
+      end
+
+      def unlock_force(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)
+          unlock_label!(name)
+          response.reply(t('label.unlock', name: name))
+          # FIXME: Handle the case where things can't be unlocked?
+        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_', '')))
+        end
+      end
+
+      def label_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))
+        end
+      end
+
+      def label_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))
+        end
+      end
+
+      def label_show(response)
+        name = response.matches[0][0]
+        if label_exists?(name)
+          members = label_membership(name)
+          if members.count > 0
+            response.reply(t('label.resources', name: name,
+                                                resources: members.join(', ')))
+          else
+            response.reply(t('label.has_no_resources', name: name))
+          end
+        else
+          response.reply(t('label.does_not_exist', name: name))
+        end
+      end
+
+      def label_add(response)
+        resource_name = response.matches[0][0]
+        label_name = response.matches[0][1]
+        if label_exists?(label_name)
+          if resource_exists?(resource_name)
+            add_resource_to_label(label_name, resource_name)
+            response.reply(t('label.resource_added', label: label_name,
+                                                     resource: resource_name))
+          else
+            response.reply(t('resource.does_not_exist', name: resource_name))
+          end
+        else
+          response.reply(t('label.does_not_exist', name: label_name))
+        end
+      end
+
+      def label_remove(response)
+        resource_name = response.matches[0][0]
+        label_name = response.matches[0][1]
+        if label_exists?(label_name)
+          if 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))
+            end
+          else
+            response.reply(t('resource.does_not_exist', name: resource_name))
+          end
+        else
+          response.reply(t('label.does_not_exist', name: label_name))
+        end
+      end
+
+      def resource_list(response)
+        resources.each do |r|
+          r_name = r.sub('resource_', '')
+          res = resource(r_name)
+          response.reply(t('resource.desc', name: r_name, state: res['state']))
+        end
+      end
+
+      def resource_create(response)
+        name = response.matches[0][0]
+        if create_resource(name)
+          response.reply(t('resource.created', name: name))
+        else
+          response.reply(t('resource.exists', name: name))
+        end
+      end
+
+      def resource_delete(response)
+        name = response.matches[0][0]
+        if delete_resource(name)
+          response.reply(t('resource.deleted', name: name))
+        else
+          response.reply(t('resource.does_not_exist', name: name))
+        end
+      end
+
+      def resource_show(response)
+        name = response.matches[0][0]
+        if resource_exists?(name)
+          r = resource(name)
+          response.reply(t('resource.desc', name: name, state: r['state']))
+        else
+          response.reply(t('resource.does_not_exist', name: name))
+        end
+      end
+
+      private
+
+      def create_label(name)
+        label_key = "label_#{name}"
+        redis.hset(label_key, 'state', 'unlocked') unless
+          resource_exists?(name) || label_exists?(name)
+      end
+
+      def delete_label(name)
+        label_key = "label_#{name}"
+        redis.del(label_key) if label_exists?(name)
+      end
+
+      def label_exists?(name)
+        redis.exists("label_#{name}")
+      end
+
+      def label_membership(name)
+        redis.smembers("membership_#{name}")
+      end
+
+      def add_resource_to_label(label, resource)
+        if label_exists?(label) && resource_exists?(resource)
+          redis.sadd("membership_#{label}", resource)
+        end
+      end
+
+      def remove_resource_from_label(label, resource)
+        if label_exists?(label) && resource_exists?(resource)
+          redis.srem("membership_#{label}", resource)
+        end
+      end
+
+      def create_resource(name)
+        resource_key = "resource_#{name}"
+        redis.hset(resource_key, 'state', 'unlocked') unless
+          resource_exists?(name) || label_exists?(name)
+      end
+
+      def delete_resource(name)
+        resource_key = "resource_#{name}"
+        redis.del(resource_key) if resource_exists?(name)
+      end
+
+      def resource_exists?(name)
+        redis.exists("resource_#{name}")
+      end
+
+      def lock_resource!(name, owner, time_until)
+        if resource_exists?(name)
+          resource_key = "resource_#{name}"
+          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, 'until', time_until)
+            true
+          else
+            false
+          end
+        else
+          false
+        end
+      end
+
+      def lock_label!(name, owner, time_until)
+        if label_exists?(name)
+          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)
+          end
+          redis.hset(key, 'state', 'locked')
+          redis.hset(key, 'owner', owner.name)
+          redis.hset(key, 'until', time_until)
+          true
+        else
+          false
+        end
+      end
+
+      def unlock_resource!(name)
+        if resource_exists?(name)
+          # FIXME: Tracking here?
+          key = "resource_#{name}"
+          redis.hset(key, 'state', 'unlocked')
+          redis.hset(key, 'owner', '')
+        else
+          false
+        end
+      end
+
+      def unlock_label!(name)
+        if label_exists?(name)
+          key = "label_#{name}"
+          members = label_membership(name)
+          members.each do |m|
+            unlock_resource!(m)
+          end
+          redis.hset(key, 'state', 'unlocked')
+          redis.hset(key, 'owner', '')
+          true
+        else
+          false
+        end
+      end
+
+      def resource(name)
+        redis.hgetall("resource_#{name}")
+      end
+
+      def resources
+        redis.keys('resource_*')
+      end
+
+      def label(name)
+        redis.hgetall("label_#{name}")
+      end
+
+      def labels
+        redis.keys('label_*')
+      end
+    end
+
+    Lita.register_handler(Locker)
+  end
+end

data/lita-locker.gemspec

@@ -0,0 +1,25 @@
+Gem::Specification.new do |spec|
+  spec.name          = 'lita-locker'
+  spec.version       = '0.3.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.homepage      = 'https://github.com/esigler/lita-locker'
+  spec.license       = 'MIT'
+  spec.metadata      = { 'lita_plugin_type' => 'handler' }
+
+  spec.files         = `git ls-files`.split($INPUT_RECORD_SEPARATOR)
+  spec.executables   = spec.files.grep(/^bin\//) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(/^(test|spec|features)\//)
+  spec.require_paths = ['lib']
+
+  spec.add_runtime_dependency 'lita', '>= 3.2'
+
+  spec.add_development_dependency 'bundler', '~> 1.3'
+  spec.add_development_dependency 'rake'
+  spec.add_development_dependency 'rspec', '>= 3.0.0.beta2'
+  spec.add_development_dependency 'simplecov'
+  spec.add_development_dependency 'coveralls'
+  spec.add_development_dependency 'rubocop'
+end

data/locales/en.yml

@@ -0,0 +1,61 @@
+en:
+  lita:
+    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>
+        resource:
+          created: "Resource %{name} created"
+          desc: "Resource: %{name}, state: %{state}"
+          exists: "%{name} already exists"
+          deleted: "Resource %{name} deleted"
+          does_not_exist: "Resource %{name} does not exist"
+          lock: "%{name} locked"
+          is_locked: "%{name} is locked"
+          unlock: "%{name} unlocked"
+          is_unlocked: "%{name} is unlocked"
+          owned: "%{name} is locked by %{owner}"
+        subject:
+          does_not_exist: "%{name} does not exist"
+        label:
+          unlock: "%{name} unlocked"
+          owned: "%{name} is locked by %{owner}"
+          is_unlocked: "%{name} is unlocked"
+          unable_to_lock: "%{name} unable to be locked"
+          lock: "%{name} locked"
+          desc: "Label: %{name}"
+          created: "Label %{name} created"
+          exists: "%{name} already exists"
+          deleted: "Label %{name} deleted"
+          does_not_exist: "Label %{name} does not exist"
+          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"

data/spec/lita/handlers/locker_spec.rb

@@ -0,0 +1,352 @@
+require 'spec_helper'
+
+describe Lita::Handlers::Locker, lita_handler: true do
+#  it { routes('(lock) foobar').to(:lock) }
+#  it { routes('(unlock) foobar').to(:unlock) }
+
+  it { routes_command('lock foobar').to(:lock) }
+#  it { routes_command('lock foobar 30m').to(:lock) }
+
+  it { routes_command('unlock foobar').to(:unlock) }
+  it { routes_command('unlock foobar force').to(:unlock_force) }
+
+  it { routes_command('locker resource list').to(:resource_list) }
+  it { routes_command('locker resource create foobar').to(:resource_create) }
+  it { routes_command('locker resource delete foobar').to(:resource_delete) }
+  it { routes_command('locker resource show foobar').to(:resource_show) }
+
+  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) }
+
+  it { routes_http(:get, '/locker/label/foobar').to(:http_label_show) }
+  it { routes_http(:get, '/locker/resource/foobar').to(:http_resource_show) }
+
+  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
+
+    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('locker resource show foobar')
+      expect(replies.last).to eq('Resource: foobar, state: locked')
+    end
+
+    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, ' \
+                                 '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 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')
+    end
+
+    it 'shows an error when a <subject> 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
+  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')
+    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')
+    end
+
+    it 'shows a warning when a label is already unlocked' do
+      send_command('locker resource create foobar')
+      send_command('locker label create bazbat')
+      send_command('locker label add foobar to bazbat')
+      send_command('unlock bazbat')
+      send_command('unlock bazbat')
+      expect(replies.last).to eq('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')
+    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
+
+    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')
+    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')
+    end
+  end
+
+  describe '#label_list' do
+    it 'shows a list of labels if there are any' do
+      send_command('locker label create foobar')
+      send_command('locker label create bazbat')
+      send_command('locker label list')
+      expect(replies.last).to eq('Label: bazbat')
+    end
+  end
+
+  describe '#label_create' do
+    it 'creates a label with <name>' do
+      send_command('locker label create foobar')
+      expect(replies.last).to eq('Label foobar created')
+    end
+
+    it 'shows a warning when the <name> already exists as a label' do
+      send_command('locker label create foobar')
+      send_command('locker label create foobar')
+      expect(replies.last).to eq('foobar already exists')
+    end
+
+    it 'shows a warning when the <name> already exists as a resource' do
+      send_command('locker resource create foobar')
+      send_command('locker label create foobar')
+      expect(replies.last).to eq('foobar already exists')
+    end
+  end
+
+  describe '#label_delete' do
+    it 'deletes a label with <name>' do
+      send_command('locker label create foobar')
+      send_command('locker label delete foobar')
+      expect(replies.last).to eq('Label foobar deleted')
+    end
+
+    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')
+    end
+  end
+
+  describe '#label_show' do
+    it 'shows a list of resources for a label if there are any' do
+      send_command('locker resource create whatever')
+      send_command('locker label create foobar')
+      send_command('locker label add whatever to foobar')
+      send_command('locker label show foobar')
+      expect(replies.last).to eq('Label foobar has: whatever')
+    end
+
+    it 'shows a warning if there are no resources for the label' do
+      send_command('locker label create foobar')
+      send_command('locker label show foobar')
+      expect(replies.last).to eq('Label foobar has no resources')
+    end
+
+    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')
+    end
+  end
+
+  describe '#label_add' do
+    it 'adds a resource to a label if both exist' do
+      send_command('locker resource create foo')
+      send_command('locker label create bar')
+      send_command('locker label add foo to bar')
+      expect(replies.last).to eq('Resource foo has been added to bar')
+      send_command('locker label show bar')
+      expect(replies.last).to eq('Label bar has: foo')
+    end
+
+    it 'adds multiple resources to a label if all exist' do
+      send_command('locker resource create foo')
+      send_command('locker resource create baz')
+      send_command('locker label create bar')
+      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')
+    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')
+    end
+
+    it 'shows an error if the resource does not exist' do
+      send_command('locker label create bar')
+      send_command('locker label add foo to bar')
+      expect(replies.last).to eq('Resource foo does not exist')
+    end
+  end
+
+  describe '#label_remove' do
+    it 'removes a resource from a label if both exist and are related' do
+      send_command('locker resource create foo')
+      send_command('locker label create bar')
+      send_command('locker label add foo to bar')
+      send_command('locker label remove foo from bar')
+      send_command('locker label show bar')
+      expect(replies.last).to eq('Label bar has no resources')
+    end
+
+    it 'shows an error if they both exist but are not related' do
+      send_command('locker resource create foo')
+      send_command('locker label create bar')
+      send_command('locker label remove foo from bar')
+      expect(replies.last).to eq('Label bar does not have Resource foo')
+    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')
+    end
+
+    it 'shows an error if the resource does not exist' do
+      send_command('locker label create bar')
+      send_command('locker label add foo to bar')
+      expect(replies.last).to eq('Resource foo does not exist')
+    end
+  end
+
+  describe '#resource_list' do
+    it 'shows a list of resources if there are any' do
+      send_command('locker resource create foobar')
+      send_command('locker resource create bazbat')
+      send_command('locker resource list')
+      expect(replies.last).to eq('Resource: foobar, state: unlocked')
+    end
+  end
+
+  describe '#resource_create' do
+    it 'creates a resource with <name>' do
+      send_command('locker resource create foobar')
+      expect(replies.last).to eq('Resource foobar created')
+    end
+
+    it 'shows a warning when the <name> already exists as a resource' do
+      send_command('locker resource create foobar')
+      send_command('locker resource create foobar')
+      expect(replies.last).to eq('foobar already exists')
+    end
+
+    it 'shows a warning when the <name> already exists as a label' do
+      send_command('locker label create foobar')
+      send_command('locker resource create foobar')
+      expect(replies.last).to eq('foobar already exists')
+    end
+  end
+
+  describe '#resource_delete' do
+    it 'deletes a resource with <name>' do
+      send_command('locker resource create foobar')
+      send_command('locker resource delete foobar')
+      expect(replies.last).to eq('Resource foobar deleted')
+    end
+
+    it 'shows a warning when <name> does not exist' do
+      send_command('locker resource delete foobar')
+      expect(replies.last).to eq('Resource foobar does not exist')
+    end
+  end
+
+  describe '#resource_show' do
+    it 'shows the state of a <name> if it exists' 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
+      send_command('locker resource show foobar')
+      expect(replies.last).to eq('Resource foobar does not exist')
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require 'simplecov'
+require 'coveralls'
+SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
+  SimpleCov::Formatter::HTMLFormatter,
+  Coveralls::SimpleCov::Formatter
+]
+SimpleCov.start { add_filter '/spec/' }
+
+require 'lita-locker'
+require 'lita/rspec'

metadata

@@ -0,0 +1,158 @@
+--- !ruby/object:Gem::Specification
+name: lita-locker
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+platform: ruby
+authors:
+- Eric Sigler
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-06-16 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: lita
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0.beta2
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: "\"lock\" and \"unlock\" arbitrary subjects"
+email:
+- me@esigler.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rubocop.yml"
+- ".travis.yml"
+- Gemfile
+- LICENSE
+- README.md
+- Rakefile
+- lib/lita-locker.rb
+- lib/lita/handlers/locker.rb
+- lita-locker.gemspec
+- locales/en.yml
+- spec/lita/handlers/locker_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/esigler/lita-locker
+licenses:
+- MIT
+metadata:
+  lita_plugin_type: handler
+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.2.1
+signing_key: 
+specification_version: 4
+summary: "\"lock\" and \"unlock\" arbitrary subjects"
+test_files:
+- spec/lita/handlers/locker_spec.rb
+- spec/spec_helper.rb