Remove helper function usage

lib/lita/handlers/locker.rb

@@ -56,21 +56,23 @@ def lock(response)
       def unlock(response)
         name = response.matches[0][0]
         return response.reply(t('subject.does_not_exist', name: name)) unless Label.exists?(name)
-        return response.reply(t('label.is_unlocked', name: name)) unless label_locked?(name)
+        l = Label.new(name)
+        return response.reply(t('label.is_unlocked', name: name)) unless l.locked?
         response.reply(attempt_unlock(name, response.user))
       end
 
       def steal(response)
         name = response.matches[0][0]
         return response.reply(t('subject.does_not_exist', name: name)) unless Label.exists?(name)
-        return response.reply(t('steal.already_unlocked', label: name)) unless label_locked?(name)
+        l = Label.new(name)
+        return response.reply(t('steal.already_unlocked', label: name)) unless l.locked?
         response.reply(attempt_steal(name, response.user))
       end
 
       private
 
       def attempt_steal(name, user)
-        label = label(name)
+        label = Label.new(name)
         o = Lita::User.find_by_id(label.owner_id.value)
         return t('steal.self') if o.id == user.id
         label.steal!(user.id)
@@ -79,7 +81,7 @@ def attempt_steal(name, user)
       end
 
       def attempt_unlock(name, user)
-        label = label(name)
+        label = Label.new(name)
         if user.id == label.owner_id.value
           label.unlock!
           if label.locked?

lib/lita/handlers/locker_events.rb

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

lib/lita/handlers/locker_http.rb

@@ -15,13 +15,13 @@ class LockerHttp < Handler
       def http_label_show(request, response)
         name = request.env['router.params'][:name]
         response.headers['Content-Type'] = 'application/json'
-        response.write(label(name).to_json)
+        response.write(Label.new(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)
+        response.write(Resource.new(name).to_json)
       end
 
       Lita.register_handler(LockerHttp)

lib/lita/handlers/locker_labels.rb

@@ -52,15 +52,15 @@ class LockerLabels < Handler
       )
 
       def list(response)
-        labels.sort.each do |n|
+        Label.list.each do |n|
           l = Label.new(n)
           response.reply(t('label.desc', name: n, state: l.state.value))
         end
       end
 
       def create(response)
         name = response.matches[0][0]
-        if create_label(name)
+        if !Label.exists?(name) && Label.create(name)
           response.reply(t('label.created', name: name))
         else
           response.reply(t('label.exists', name: name))
@@ -79,10 +79,10 @@ def delete(response)
       def show(response)
         name = response.matches[0][0]
         return response.reply(t('label.does_not_exist', name: name)) unless Label.exists?(name)
-        members = label_membership(name)
-        return response.reply(t('label.has_no_resources', name: name)) unless members.count > 0
+        l = Label.new(name)
+        return response.reply(t('label.has_no_resources', name: name)) unless l.membership.count > 0
         res = []
-        members.each do |member|
+        l.membership.each do |member|
           res.push(member)
         end
         response.reply(t('label.resources', name: name, resources: res.join(', ')))
@@ -92,19 +92,22 @@ def add(response)
         resource_name = response.matches[0][0]
         label_name = response.matches[0][1]
         return response.reply(t('label.does_not_exist', name: label_name)) unless Label.exists?(label_name)
-        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
-        add_resource_to_label(label_name, resource_name)
+        return response.reply(t('resource.does_not_exist', name: resource_name)) unless Resource.exists?(resource_name)
+        l = Label.new(label_name)
+        r = Resource.new(resource_name)
+        l.add_resource(r)
         response.reply(t('label.resource_added', label: label_name, resource: resource_name))
       end
 
       def remove(response)
         resource_name = response.matches[0][0]
         label_name = response.matches[0][1]
         return response.reply(t('label.does_not_exist', name: label_name)) unless Label.exists?(label_name)
-        return response.reply(t('resource.does_not_exist', name: resource_name)) unless resource_exists?(resource_name)
-        members = label_membership(label_name)
-        if members.include?(resource_name)
-          remove_resource_from_label(label_name, resource_name)
+        return response.reply(t('resource.does_not_exist', name: resource_name)) unless Resource.exists?(resource_name)
+        l = Label.new(label_name)
+        if l.membership.include?(resource_name)
+          r = Resource.new(resource_name)
+          l.remove_resource(r)
           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))

lib/lita/handlers/locker_misc.rb

@@ -33,7 +33,7 @@ class LockerMisc < Handler
       def status(response)
         name = response.matches[0][0]
         if Label.exists?(name)
-          l = label(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
@@ -54,8 +54,8 @@ def status(response)
           else
             response.reply(t('label.desc', name: name, state: l.state.value))
           end
-        elsif resource_exists?(name)
-          r = resource(name)
+        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))

lib/lita/handlers/locker_resources.rb

@@ -45,8 +45,8 @@ class LockerResources < Handler
 
       def list(response)
         output = ''
-        resources.each do |r|
-          res = resource(r)
+        Resource.list.each do |r|
+          res = Resource.new(r)
           output += t('resource.desc', name: r, state: res.state.value)
         end
         response.reply(output)
@@ -55,21 +55,21 @@ def list(response)
       def create(response)
         name = response.matches[0][0]
         return response.reply(t('resource.exists', name: name)) if Resource.exists?(name)
-        create_resource(name)
+        Resource.create(name)
         response.reply(t('resource.created', name: name))
       end
 
       def delete(response)
         name = response.matches[0][0]
-        return response.reply(t('resource.does_not_exist', name: name)) unless resource_exists?(name)
-        delete_resource(name)
+        return response.reply(t('resource.does_not_exist', name: name)) unless Resource.exists?(name)
+        Resource.delete(name)
         response.reply(t('resource.deleted', name: name))
       end
 
       def show(response)
         name = response.matches[0][0]
-        return response.reply(t('resource.does_not_exist', name: name)) unless resource_exists?(name)
-        r = resource(name)
+        return response.reply(t('resource.does_not_exist', name: name)) unless Resource.exists?(name)
+        r = Resource.new(name)
         response.reply(t('resource.desc', name: name, state: r.state.value))
       end
 

lib/locker/label.rb

@@ -45,7 +45,7 @@ def self.delete(key)
       end
 
       def self.list
-        redis.smembers('label-list')
+        redis.smembers('label-list').sort
       end
 
       def self.normalize(key)
@@ -112,58 +112,9 @@ def owner
       end
     end
 
-    def label(name)
-      Label.new(name)
-    end
-
-    def labels
-      Label.list
-    end
-
-    def label_locked?(name)
-      l = Label.new(name)
-      l.locked?
-    end
-
-    def lock_label!(name, owner, _time_until)
-      l = Label.new(name)
-      l.lock!(owner.id)
-    end
-
-    def unlock_label!(name)
-      l = Label.new(name)
-      l.unlock!
-    end
-
-    def create_label(name)
-      return false if Label.exists?(name)
-      Label.create(name)
-    end
-
-    def delete_label(name)
-      Label.delete(name) if Label.exists?(name)
-    end
-
-    def label_membership(name)
-      l = Label.new(name)
-      l.membership
-    end
-
-    def add_resource_to_label(label, resource)
-      l = Label.new(label)
-      r = resource(resource)
-      l.add_resource(r)
-    end
-
-    def remove_resource_from_label(label, resource)
-      l = Label.new(label)
-      r = resource(resource)
-      l.remove_resource(r)
-    end
-
     def label_ownership(name)
-      l = label(name)
-      return label_dependencies(name) unless label_locked?(name)
+      l = Label.new(name)
+      return label_dependencies(name) unless l.locked?
       o = Lita::User.find_by_id(l.owner_id.value)
       mention = o.mention_name ? "(@#{o.mention_name})" : ''
       t('label.owned_lock', name: name, owner_name: o.name, mention: mention)
@@ -172,8 +123,9 @@ def label_ownership(name)
     def label_dependencies(name)
       msg = t('label.dependency') + "\n"
       deps = []
-      label_membership(name).each do |resource_name|
-        resource = resource(resource_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}"

lib/locker/misc.rb

@@ -4,8 +4,8 @@ module Locker
   module Misc
     def user_locks(user)
       owned = []
-      labels.each do |name|
-        label = label(name)
+      Locker::Label::Label.list.each do |name|
+        label = Locker::Label::Label.new(name)
         owned.push(name) if label.owner_id.value == user.id
       end
       owned

lib/locker/resource.rb

@@ -42,7 +42,7 @@ def self.delete(key)
       end
 
       def self.list
-        redis.smembers('resource-list')
+        redis.smembers('resource-list').sort
       end
 
       def lock!(owner_id)
@@ -63,35 +63,5 @@ def unlock!
         true
       end
     end
-
-    def resource(name)
-      Resource.new(name)
-    end
-
-    def resources
-      Resource.list
-    end
-
-    def resource_exists?(name)
-      Resource.exists?(name)
-    end
-
-    def lock_resource!(name, owner, _time_until)
-      r = Resource.new(name)
-      r.lock!(owner.id)
-    end
-
-    def unlock_resource!(name)
-      r = Resource.new(name)
-      r.unlock!
-    end
-
-    def create_resource(name)
-      Resource.create(name)
-    end
-
-    def delete_resource(name)
-      Resource.delete(name)
-    end
   end
 end