Reduce complexity some, switch to more class usage

.rubocop.yml

@@ -6,15 +6,7 @@ LineLength:
   Max: 120
 
 AbcSize:
-  Exclude:
-    - lib/lita/handlers/locker_misc.rb
-  Max: 30
+  Max: 26
 
 MethodLength:
   Max: 17
-  Exclude:
-    - lib/lita/handlers/locker_misc.rb
-
-PerceivedComplexity:
-  Exclude:
-    - lib/lita/handlers/locker_misc.rb

lib/lita/handlers/locker.rb

@@ -47,7 +47,7 @@ def lock(response)
         return response.reply(t('label.does_not_exist', name: name)) unless Label.exists?(name)
         l = Label.new(name)
         return response.reply(t('label.no_resources', name: name)) unless l.membership.count > 0
-        return response.reply(t('label.self_lock', name: name)) if l.owner_id.value == response.user.id
+        return response.reply(t('label.self_lock', name: name)) if l.owner == response.user
         return response.reply(t('label.lock', name: name)) if l.lock!(response.user.id)
 
         response.reply(label_ownership(name))
@@ -73,28 +73,26 @@ def steal(response)
 
       def attempt_steal(name, user)
         label = Label.new(name)
-        o = Lita::User.find_by_id(label.owner_id.value)
-        return t('steal.self') if o.id == user.id
+        return t('steal.self') if label.owner == user
+        old_owner = label.owner
         label.steal!(user.id)
-        mention = o.mention_name ? "(@#{o.mention_name})" : ''
-        t('steal.stolen', label: name, old_owner: o.name, mention: mention)
+        mention = old_owner.mention_name ? "(@#{old_owner.mention_name})" : ''
+        t('steal.stolen', label: name, old_owner: old_owner.name, mention: mention)
       end
 
       def attempt_unlock(name, user)
         label = Label.new(name)
-        if user.id == label.owner_id.value
+        if label.owner == user
           label.unlock!
           if label.locked?
-            o = Lita::User.find_by_id(label.owner_id.value)
-            mention = o.mention_name ? "(@#{o.mention_name})" : ''
-            t('label.now_locked_by', name: name, owner: o.name, mention: mention)
+            mention = label.owner.mention_name ? "(@#{label.owner.mention_name})" : ''
+            t('label.now_locked_by', name: name, owner: label.owner.name, mention: mention)
           else
             t('label.unlock', name: name)
           end
         else
-          o = Lita::User.find_by_id(label.owner_id.value)
-          mention = o.mention_name ? "(@#{o.mention_name})" : ''
-          t('label.owned_unlock', name: name, owner_name: o.name, mention: mention)
+          mention = label.owner.mention_name ? "(@#{label.owner.mention_name})" : ''
+          t('label.owned_unlock', name: name, owner_name: label.owner.name, mention: mention)
         end
       end
     end

lib/lita/handlers/locker_misc.rb

@@ -32,34 +32,9 @@ class LockerMisc < Handler
 
       def status(response)
         name = response.match_data['label']
-        if Label.exists?(name)
-          l = Label.new(name)
-          if l.owner_id.value != ''
-            o = Lita::User.find_by_id(l.owner_id.value)
-            if l.wait_queue.count > 0
-              queue = []
-              l.wait_queue.each do |u|
-                usr = Lita::User.find_by_id(u)
-                queue.push(usr.name)
-              end
-              response.reply(t('label.desc_owner_queue', name: name,
-                                                         state: l.state.value,
-                                                         owner_name: o.name,
-                                                         queue: queue.join(', ')))
-            else
-              response.reply(t('label.desc_owner', name: name,
-                                                   state: l.state.value,
-                                                   owner_name: o.name))
-            end
-          else
-            response.reply(t('label.desc', name: name, state: l.state.value))
-          end
-        elsif Resource.exists?(name)
-          r = Resource.new(name)
-          response.reply(t('resource.desc', name: name, state: r.state.value))
-        else
-          response.reply(t('subject.does_not_exist', name: name))
-        end
+        return response.reply(status_label(name)) if Label.exists?(name)
+        return response.reply(status_resource(name)) if Resource.exists?(name)
+        response.reply(t('subject.does_not_exist', name: name))
       end
 
       def dequeue(response)
@@ -83,6 +58,33 @@ def list(response)
         response.reply(composed)
       end
 
+      private
+
+      def status_label(name)
+        l = Label.new(name)
+        return t('label.desc', name: name, state: l.state.value) unless l.locked?
+        if l.wait_queue.count > 0
+          queue = []
+          l.wait_queue.each do |u|
+            usr = Lita::User.find_by_id(u)
+            queue.push(usr.name)
+          end
+          t('label.desc_owner_queue', name: name,
+                                      state: l.state.value,
+                                      owner_name: l.owner.name,
+                                      queue: queue.join(', '))
+        else
+          t('label.desc_owner', name: name,
+                                state: l.state.value,
+                                owner_name: l.owner.name)
+        end
+      end
+
+      def status_resource(name)
+        r = Resource.new(name)
+        t('resource.desc', name: name, state: r.state.value)
+      end
+
       Lita.register_handler(LockerMisc)
     end
   end

lib/locker/label.rb

@@ -108,7 +108,7 @@ def remove_resource(resource)
 
       def owner
         return nil unless locked?
-        Lita::User.find_by_id(owner_id)
+        Lita::User.find_by_id(owner_id.value)
       end
     end
 
@@ -126,9 +126,8 @@ def label_dependencies(name)
       l = Label.new(name)
       l.membership.each do |resource_name|
         resource = Locker::Resource::Resource.new(resource_name)
-        u = Lita::User.find_by_id(resource.owner_id.value)
         if resource.state.value == 'locked'
-          deps.push "#{resource_name} - #{u.name}"
+          deps.push "#{resource_name} - #{resource.owner.name}"
         end
       end
       msg += deps.join("\n")

lib/locker/misc.rb

@@ -6,7 +6,7 @@ def user_locks(user)
       owned = []
       Locker::Label::Label.list.each do |name|
         label = Locker::Label::Label.new(name)
-        owned.push(name) if label.owner_id.value == user.id
+        owned.push(name) if label.owner == user
       end
       owned
     end

lib/locker/resource.rb

@@ -62,6 +62,15 @@ def unlock!
         end
         true
       end
+
+      def locked?
+        (state == 'locked')
+      end
+
+      def owner
+        return nil unless locked?
+        Lita::User.find_by_id(owner_id.value)
+      end
     end
   end
 end