cinch-cooldown 0.0.1 → 1.0.0

data/README.md

@@ -1,5 +1,7 @@
 # Cinch::Cooldown
 
+[![Code Climate](https://codeclimate.com/github/bhaberer/cinch-cooldown.png)](https://codeclimate.com/github/bhaberer/cinch-cooldown)
+
 This library is used to add a global cooldown so that users are prevented from spamming the
 channel.
 
@@ -19,7 +21,20 @@ Or install it yourself as:
 
 ## Usage
 
-Coming Soon. :)
+Configuration Steps:
+
+1. You need to add the configuration to your bot in the config block. You will need to add
+config info for every channel the bot is in that you want a cooldown. The `:global` is how
+many seconds the bot will wait before listening to a command that prints something to the
+channel, while the `:user` directive is how long. Currently the gem is simple and assumes
+that the user timer will be greater than the global timer.
+
+    c.shared[:cooldown] = { :config => { '#bottest' => { :global => 10
+                                                         :user   => 20 } }
+
+2. If you are using this with my plugins, things should just work. However if you want to use
+this with your own plugins, yoiu need to add a `require cinch-cooldown` to the top of said
+plugin, and an `enforce_cooldown` to the plugin after the `include Cinch::Plugin` line.
 
 ## Contributing
 

data/cinch-cooldown.gemspec

@@ -17,5 +17,5 @@ Gem::Specification.new do |gem|
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
   gem.require_paths = ["lib"]
 
-  gem.add_dependency 'cinch-toolbox'
+  gem.add_dependency('time-lord', '>= 1.0.1')
 end

data/lib/cinch-cooldown/version.rb

@@ -1,5 +1,5 @@
 module Cinch
   module Cooldown
-    VERSION = "0.0.1"
+    VERSION = "1.0.0"
   end
 end

data/lib/cinch-cooldown.rb

@@ -1,5 +1,5 @@
 require 'cinch-cooldown/version'
-require 'cinch-toolbox'
+require 'time-lord'
 
 module Cinch
   module Plugin
@@ -8,76 +8,104 @@ module Cinch
         hook(:pre, :for => [:match], :method => lambda {|m| cooldown_finished?(m)})
       end
 
-      def reset_cooldown(m)
+      def reset_cooldown
          # TODO
       end
     end
 
     def cooldown_finished?(m)
+      # return if we don't have a cooldown config
       return true unless shared[:cooldown] && shared[:cooldown][:config]
       synchronize(:cooldown) do
-        return true if m.channel.nil?
+        # return if we don't have a channel (i.e. user is pming the bot)
+        return false if m.channel.nil?
 
         channel = m.channel.name
-        nick = m.user.nick
+        user    = m.user.nick
 
-        return true unless shared[:cooldown][:config][channel]
+        # Make sure the configuration is sane.
+        return true if configuration_broken?(channel)
 
-        unless shared[:cooldown].key?(channel)
-          shared[:cooldown][channel] = { 'global' => Time.now, nick => Time.now }
-          return true
-        end
+        # Make sure it's not the first command
+        return true if first_run?(channel, user)
+
+        # Check if timers are finished
+        return true if cooldowns_finished?(channel, user)
+
+        # Handle unfinished cooldowns here
+        m.user.notice cooldown_message(channel, user)
+        return false
+      end
+    end
+
+    def configuration_broken?(channel)
+      # return if the config doesn't smell right for this channel
+      return true unless shared[:cooldown][:config].key?(channel) &&
+                         shared[:cooldown][:config][channel].key?(:global) &&
+                         shared[:cooldown][:config][channel].key?(:user)
+
+    end
 
-        if channel_cooldown_finished?(channel)
-          # Global cd is up, check per user
-          if shared[:cooldown][channel].key?(nick)
-            # User's in the config, check time
-            if user_cooldown_finished?(channel, nick)
-              shared[:cooldown][channel]['global'] = Time.now
-              shared[:cooldown][channel][nick] = Time.now
-              return true
-            end
-          else
-            # User's not used bot before
-            shared[:cooldown][channel][nick] = Time.now
-            shared[:cooldown][channel]['global'] = Time.now
+    def first_run?(channel, user)
+      unless shared[:cooldown].key?(channel)
+        trigger_cooldown_for(channel, user)
+        return true
+      end
+    end
+
+    def cooldowns_finished?(channel, user)
+      # Normal usage stuff starts here, check and see if the channel time is up
+      if channel_cooldown_finished?(channel)
+        # channel cd is up, check per user by checking if the user's even triggered a cd yet
+        if shared[:cooldown][channel].key?(user)
+          # User's in the config, check time
+          if user_cooldown_finished?(channel, user)
+            # Their time's up, run the command
+            trigger_cooldown_for(channel, user)
             return true
           end
+        else
+          # User's not used bot before, run the command
+          trigger_cooldown_for(channel, user)
+          return true
         end
-
-        message = "Sorry, you'll have to wait "
-        unless channel_cooldown_finished?(channel)
-          message << "#{Cinch::Toolbox.time_format(channel_time_remaining(channel))} before I can talk in the channel again, and "
-        end
-        message << "#{Cinch::Toolbox.time_format(user_time_remaining(channel, nick))} before your nick can use any commands."
-
-        m.user.notice message
-        return false
       end
     end
 
-    def user_cooldown_finished?(chan, user)
-      shared[:cooldown][:config][chan]['user']   < user_time_elapsed(chan, user)
+    def cooldown_message(channel, user)
+      message = ['Sorry, you\'ll have to wait']
+      unless channel_cooldown_finished?(channel)
+        message << TimeLord::Period.new(cooldown_channel_expire_time(channel), Time.now).to_words
+        message << 'before I can talk in the channel again, and'
+      end
+      message << TimeLord::Period.new(cooldown_user_expire_time(channel, user), Time.now).to_words
+      message << 'before you can use any commands.'
+
+      return message.join(' ')
     end
 
-    def channel_cooldown_finished?(chan)
-      shared[:cooldown][:config][chan]['global'] < channel_time_elapsed(chan)
+    def trigger_cooldown_for(channel, user)
+      shared[:cooldown][channel] = { :global => Time.now, user => Time.now }
     end
 
-    def channel_time_remaining(chan)
-      shared[:cooldown][:config][chan]['global'] - channel_time_elapsed(chan)
+    def cooldown_channel_expire_time(channel)
+      shared[:cooldown][channel][:global] + shared[:cooldown][:config][channel][:global]
     end
 
-    def user_time_remaining(chan, user)
-      shared[:cooldown][:config][chan]['user'] - user_time_elapsed(chan, user)
+    def cooldown_user_expire_time(channel, user)
+      shared[:cooldown][channel][user] + shared[:cooldown][:config][channel][:user]
     end
 
-    def channel_time_elapsed(chan)
-      (Time.now - shared[:cooldown][chan]['global']).floor
+    def user_cooldown_finished?(channel, user)
+      cooldown  = shared[:cooldown][:config][channel][:user]
+      elapsed   = Time.now - shared[:cooldown][channel][user]
+      return cooldown < elapsed
     end
 
-    def user_time_elapsed(chan, user)
-      (Time.now - shared[:cooldown][chan][user]).floor
+    def channel_cooldown_finished?(channel)
+      cooldown  = shared[:cooldown][:config][channel][:global]
+      elapsed   = Time.now - shared[:cooldown][channel][:global]
+      return cooldown < elapsed
     end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cinch-cooldown
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,16 +9,16 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-02 00:00:00.000000000 Z
+date: 2013-05-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: cinch-toolbox
+  name: time-lord
   requirement: !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 1.0.1
 description: This gem allows you to set a shared timer across plugins that are configured
   to respect it.
 email: