lita-locker 0.5.3 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c8c1387e7b5b34330a06b4b423c09baf6a07c910
-  data.tar.gz: 7aff63b7b66afb89c1b4409be77a1e1902d4be49
+  metadata.gz: c652f7dfc79a47babe632a2f9516bfeedf1b4781
+  data.tar.gz: d4f5f7802f48182a08fab5f573f44b35ecac6b90
 SHA512:
-  metadata.gz: 3dd3c6ae9eaa86fd70333347c288509022b7cd056db2daab328d185210dd4ec5e02e9bd2ff1028094aa361f9ddd0acf61b7ae83f8b7b2cf0e544f1d0157d23ee
-  data.tar.gz: d2da98d29c48a71b87795a41e7377b11f00aba25e95234bf4e05d4311fa1a2669dc70e1bc7ca84995644d949603be2d26a3e8c9dfc6f5a3b7b6cb99e8482d2f9
+  metadata.gz: c9113338335470eca38f6b2b947618b115c624ffeea5dc81acf94e43636bb1aaecc359f00128653784aace1ed48647e2da0ec5dad5318d90b533e361d66a5fe5
+  data.tar.gz: 2acb94c1f70b702c67baedb3e2cd8095a68c79517c1ec46e57558e8d755e18a203bc5d6987181301999ce1e67aada7cb028fe91289291e0a55bf650b50dad748

data/.gitignore

@@ -1,5 +1,6 @@
 *.gem
 *.rbc
+*.swp
 .bundle
 .config
 .yardoc

data/.rubocop.yml

@@ -1,26 +1,21 @@
-BlockNesting:
-  Max: 5
-
 ClassLength:
-  Max: 500
+  Max: 103
 
 CyclomaticComplexity:
-  Max: 8
-
-Documentation:
-  Exclude:
-    - lib/lita/handlers/locker.rb
+  Max: 7
 
 FileName:
   Exclude:
     - lib/lita-locker.rb
 
 MethodLength:
-  Max: 200
+ Max: 31
+
+PerceivedComplexity:
+  Max: 12
 
 LineLength:
-  Max: 85
+  Max: 120
 
-GuardClause:
-  Exclude:
-    - lib/lita/handlers/locker.rb
+AbcSize:
+  Max: 49

data/.travis.yml

@@ -1,6 +1,6 @@
 language: ruby
 rvm:
-  - 2.0.0
+  - 2.1
 script: bundle exec rake
 before_install:
   - gem update --system

data/CONTRIBUTING.md

@@ -0,0 +1,9 @@
+Pull requests are awesome!  Pull requests with tests are even more awesome!
+
+## Quick steps
+
+1. Fork the repo.
+2. Run the tests: `bundle && rake`
+3. Add a test for your change. Only refactoring and documentation changes require no new tests. If you are adding functionality or fixing a bug, it needs a test!
+4. Make the test pass.
+5. Push to your fork and submit a pull request.

data/Gemfile

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

data/lib/lita-locker.rb

@@ -4,4 +4,14 @@ Lita.load_locales Dir[File.expand_path(
   File.join('..', '..', 'locales', '*.yml'), __FILE__
 )]
 
+require 'locker/label'
+require 'locker/misc'
+require 'locker/regex'
+require 'locker/resource'
+
+require 'lita/handlers/locker_events'
+require 'lita/handlers/locker_http'
+require 'lita/handlers/locker_labels'
+require 'lita/handlers/locker_misc'
+require 'lita/handlers/locker_resources'
 require 'lita/handlers/locker'

data/lib/lita/handlers/locker.rb

@@ -1,20 +1,20 @@
 module Lita
+  # Handy, isn't it?
   module Handlers
+    # Top-level class for Locker
     class Locker < Handler
-      http.get '/locker/label/:name', :http_label_show
-      http.get '/locker/resource/:name', :http_resource_show
-
-      LABEL_REGEX    = /([\.\w\s-]+)/
-      RESOURCE_REGEX = /([\.\w-]+)/
-      COMMENT_REGEX  = /(\s\#.+)?/
+      include ::Locker::Label
+      include ::Locker::Misc
+      include ::Locker::Regex
+      include ::Locker::Resource
 
       route(
-        /^\(lock\)\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
+        /^#{LOCK_REGEX}#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :lock
       )
 
       route(
-        /^(?:\(unlock\)|\(release\))\s#{LABEL_REGEX}#{COMMENT_REGEX}$/,
+        /^#{UNLOCK_REGEX}#{LABEL_REGEX}#{COMMENT_REGEX}$/,
         :unlock
       )
 
@@ -39,435 +39,84 @@ module Lita
         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.syntax') => t('help.resource.list.desc') }
-      )
-
-      route(
-        /^locker\sresource\screate\s#{RESOURCE_REGEX}$/,
-        :resource_create,
-        command: true,
-        restrict_to: [:locker_admins],
-        help: {
-          t('help.resource.create.syntax') => t('help.resource.create.desc')
-        }
-      )
-
-      route(
-        /^locker\sresource\sdelete\s#{RESOURCE_REGEX}$/,
-        :resource_delete,
-        command: true,
-        restrict_to: [:locker_admins],
-        help: {
-          t('help.resource.delete.syntax') => t('help.resource.delete.desc')
-        }
-      )
-
-      route(
-        /^locker\sresource\sshow\s#{RESOURCE_REGEX}$/,
-        :resource_show,
-        command: true,
-        help: { t('help.resource.show.syntax') => t('help.resource.show.desc') }
-      )
-
-      route(
-        /^locker\slabel\slist$/,
-        :label_list,
-        command: true,
-        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.syntax') => t('help.label.create.desc') }
-      )
-
-      route(
-        /^locker\slabel\sdelete\s#{LABEL_REGEX}$/,
-        :label_delete,
-        command: true,
-        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.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.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.syntax') => t('help.label.remove.desc') }
-      )
-
-      def http_label_show(request, response)
-        name = request.env['router.params'][:name]
-        response.headers['Content-Type'] = 'application/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'
-        response.write(resource(name).to_json)
-      end
-
       def lock(response)
         name = response.matches[0][0]
 
-        if label_exists?(name)
-          m = label_membership(name)
-          if m.count > 0
-            if lock_label!(name, response.user, nil)
-              response.reply('(successful) ' + t('label.lock', name: name))
-            else
-              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
-                response.reply('(failed) ' + t('label.dependency'))
-              end
-            end
+        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.no_resources', name: name))
+            response.reply('(failed) ' + t('label.owned',
+                                           name: name,
+                                           owner_name: o.name))
           end
         else
-          response.reply('(failed) ' + t('label.does_not_exist', name: name))
-        end
-      end
-
-      def unlock(response)
-        name = response.matches[0][0]
-        if label_exists?(name)
-          l = label(name)
-          if l['state'] == 'unlocked'
-            response.reply('(successful) ' + t('label.is_unlocked',
-                                               name: name))
-          else
-            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
+          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
-        else
-          response.reply('(failed) ' + t('subject.does_not_exist', name: name))
+          msg += deps.join("\n")
+          response.reply(msg)
         end
       end
 
-      def steal(response)
+      def unlock(response)
         name = response.matches[0][0]
-        if label_exists?(name)
+        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))
-          # 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)
-          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))
-        end
-      end
-
-      def label_list(response)
-        labels.each do |n|
-          name = n.sub('label_', '')
-          l = label(name)
-          response.reply(t('label.desc', name: name, state: l['state']))
-        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))
+          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(t('resource.does_not_exist', name: resource_name))
+            response.reply('(failed) ' + t('label.owned',
+                                           name: name,
+                                           owner_name: o.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)
-        output = ''
-        resources.each do |r|
-          r_name = r.sub('resource_', '')
-          res = resource(r_name)
-          output += t('resource.desc', name: r_name, state: res['state'])
-        end
-        response.reply(output)
-      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)
+      def steal(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!
-            redis.hset(resource_key, 'state', 'locked')
-            redis.hset(resource_key, 'owner_id', owner.id)
-            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|
-            return false unless lock_resource!(m, owner, time_until)
-          end
-          redis.hset(key, 'state', 'locked')
-          redis.hset(key, 'owner_id', owner.id)
-          redis.hset(key, 'until', time_until)
-          true
-        else
-          false
-        end
-      end
-
-      def unlock_resource!(name)
-        if resource_exists?(name)
-          key = "resource_#{name}"
-          redis.hset(key, 'state', 'unlocked')
-          redis.hset(key, 'owner_id', '')
-        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_id', '')
-          true
+        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))
         else
-          false
+          response.reply(t('steal.self'))
         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)