cinch-cooldown 1.0.1 → 1.1.3

data/cinch-cooldown.gemspec

@@ -4,24 +4,25 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'cinch/cooldown/version'
 
 Gem::Specification.new do |gem|
-  gem.name          = "cinch-cooldown"
-  gem.version       = Cinch::Cooldown::VERSION
-  gem.authors       = ["Brian Haberer"]
-  gem.email         = ["bhaberer@gmail.com"]
+  gem.name          = 'cinch-cooldown'
+  gem.version       = Cinch::Cooldowns::VERSION
+  gem.authors       = ['Brian Haberer']
+  gem.email         = ['bhaberer@gmail.com']
   gem.description   = %q{This gem allows you to set a shared timer across plugins that are configured to respect it.}
   gem.summary       = %q{Global Cooldown tracker for Cinch Plugins}
-  gem.homepage      = "https://github.com/bhaberer/cinch-cooldown"
+  gem.homepage      = 'https://github.com/bhaberer/cinch-cooldown'
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
   gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
-  gem.require_paths = ["lib"]
+  gem.require_paths = ['lib']
+  gem.license       = 'MIT'
 
-  gem.add_development_dependency 'rake'
-  gem.add_development_dependency 'rspec'
-  gem.add_development_dependency 'coveralls'
-  gem.add_development_dependency 'cinch-test'
+  gem.add_development_dependency  'rake'
+  gem.add_development_dependency  'rspec'
+  gem.add_development_dependency  'coveralls'
+  gem.add_development_dependency  'cinch-test'
 
-  gem.add_dependency    'time-lord',      '~> 1.0.1'
-  gem.add_dependency    'cinch',          '~> 2.0.5'
+  gem.add_dependency              'time-lord',      '~> 1.0.1'
+  gem.add_dependency              'cinch',          '~> 2.0.12'
 end

data/lib/cinch/cooldown.rb

@@ -1,120 +1,6 @@
+# -*- coding: utf-8 -*-
 require 'cinch/cooldown/version'
+require 'cinch/plugin/hooks'
+require 'cinch/plugin/cooldown'
+require 'cinch/plugin/cooldowns'
 require 'time-lord'
-
-module Cinch
-  module Plugin
-    module ClassMethods
-      def enforce_cooldown
-        hook(:pre, :for => [:match], :method => lambda {|m| cooldown_finished?(m)})
-      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 if we don't have a channel (i.e. user is pming the bot)
-        return true if m.channel.nil?
-
-        channel = m.channel.name
-        user    = m.user.nick
-
-        # Make sure the configuration is sane.
-        return true if configuration_broken?(channel)
-
-        # 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) &&
-                         config_for(channel).key?(:global) &&
-                         config_for(channel).key?(:user)
-      false
-    end
-
-    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
-      end
-      return false
-    end
-
-    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 trigger_cooldown_for(channel, user)
-      shared[:cooldown][channel] = { :global => Time.now, user => Time.now }
-    end
-
-    def cooldown_channel_expire_time(channel)
-      global_cooldown_for(channel) + config_for(channel)[:global]
-    end
-
-    def cooldown_user_expire_time(channel, user)
-      user_cooldown_for(channel, user) + config_for(channel)[:user]
-    end
-
-    def user_cooldown_finished?(channel, user)
-      cooldown  = config_for(channel)[:user]
-      elapsed   = Time.now - user_cooldown_for(channel, user)
-      return cooldown <= elapsed
-    end
-
-    def channel_cooldown_finished?(channel)
-      cooldown  = config_for(channel)[:global]
-      elapsed   = Time.now - global_cooldown_for(channel)
-      return cooldown <= elapsed
-    end
-
-    def config_for(chan)
-      shared[:cooldown][:config][chan]
-    end
-
-    def global_cooldown_for(chan)
-      shared[:cooldown][chan][:global] ||= Time.now
-    end
-
-    def user_cooldown_for(chan, nick)
-      shared[:cooldown][chan][nick] || Time.now
-    end
-  end
-end

data/lib/cinch/cooldown/version.rb

@@ -1,5 +1,7 @@
+# -*- coding: utf-8 -*-
 module Cinch
-  module Cooldown
-    VERSION = "1.0.1"
+  # Versioning info
+  module Cooldowns
+    VERSION = '1.1.3'
   end
 end

data/lib/cinch/plugin/cooldown.rb

@@ -0,0 +1,30 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  module Plugin
+    # An alteration to the Plugin Module to allow for configurable cooldowns.
+    class Cooldown
+      attr_accessor :time, :duration, :expires_at
+
+      def initialize(duration, time = Time.now)
+        @time = time
+        @duration = duration
+        @expires_at = @time + @duration
+      end
+
+      def time_till_expire_in_words
+        return 'until right now' if (expires_at - Time.now) < 0
+        TimeLord::Period.new(expires_at, Time.now).to_words
+      end
+
+      def time_till_expire
+        period = @expires_at - Time.now
+        return 0 if period < 0
+        period
+      end
+
+      def cooled_down?
+        time_till_expire.zero?
+      end
+    end
+  end
+end

data/lib/cinch/plugin/cooldowns.rb

@@ -0,0 +1,128 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  module Plugin
+    module Cooldowns
+      include Cinch::Plugin
+
+      @cooldowns = {}
+      @config = nil
+
+      # Main method called by the hook
+      def self.finished?(m, shared, bot)
+        return unless shared.is_a?(Hash)
+        @config     = shared[:config]
+        @cooldowns  = shared[:cooldowns] if shared.key?(:cooldowns)
+
+        # Don't run if we there's no cooldown config
+        return true unless @config
+
+        bot.synchronize(:cooldown) do
+          # Avoid cooldown if we don't have a channel
+          #   (i.e. user is pming the bot)
+          return true if m.channel.nil?
+
+          clean_expired_cooldowns(m.channel.name)
+
+          # return true if the cooldowns have expired
+          return true if cool?(m.channel.name, m.user.nick)
+
+          # Otherwise message the user about unfinished cooldowns
+          m.user.notice message(m.channel.name, m.user.nick)
+
+          # and return false so the command gets dropped by the hook
+          false
+        end
+      end
+
+      # Main cooldown data check
+      def self.cool?(channel, user)
+        # Make sure the configuration is sane.
+        return true if config_broken?(channel) ||
+                       # Make sure it's not the first command
+                       first_run?(channel, user) ||
+                       # Check if timers are finished
+                       cooldowns_finished?(channel, user)
+
+        # Otherwise trigger cooldown
+        false
+      end
+
+      def self.config_broken?(channel)
+        # return true if the config doesn't have needed info this channel
+        return true unless @config.key?(channel) &&
+                           config_for(channel).key?(:global) &&
+                           config_for(channel).key?(:user)
+        # otherwise abort cooldown enforcement
+        false
+      end
+
+      def self.config_for(chan)
+        @config[chan]
+      end
+
+      def self.first_run?(channel, user)
+        unless @cooldowns.key?(channel)
+          trigger_cooldown_for(channel, user)
+          return true
+        end
+        false
+      end
+
+      def self.purge!
+        @cooldowns = {}
+      end
+
+      def self.cooldowns_finished?(channel, user)
+        # Chuck all the cooldowns that have expired
+        clean_expired_cooldowns(channel)
+
+        # if the channel's cooldown is up
+        if @cooldowns[channel][:global].nil?
+          # And their cd's up, or they've not used bot before, run the command
+          if @cooldowns[channel][user].nil?
+            # trigger a new cooldown
+            trigger_cooldown_for(channel, user)
+            # and run the command
+            return true
+          end
+        end
+        false
+      end
+
+      def self.clean_expired_cooldowns(channel)
+        return unless @cooldowns.key?(channel)
+        @cooldowns[channel].each_pair do |key, cooldown|
+          if cooldown.cooled_down?
+            @cooldowns[channel].delete(key)
+          end
+        end
+      end
+
+      def self.message(channel, user)
+        cds = []
+        if @cooldowns[channel].key?(:global)
+          chan_exp = @cooldowns[channel][:global].time_till_expire_in_words
+          cds << "#{chan_exp} before I can talk in the channel again"
+        elsif @cooldowns[channel].key?(user)
+          user_exp = @cooldowns[channel][user].time_till_expire_in_words
+          cds << "#{user_exp} before you can use any commands"
+        end
+        ['Sorry, cooldown is in effect:', cds.join(', and ')].join(' ')
+      end
+
+      def self.trigger_cooldown_for(channel, user)
+        # Make sure the channel array has been init
+        @cooldowns[channel] ||= {}
+
+        # Create a cooldown for the channel
+        @cooldowns[channel][:global] =
+          Cooldown.new(@config[channel][:global])
+        # Create a cooldown for the user
+        @cooldowns[channel][user] =
+          Cooldown.new(@config[channel][:user])
+
+        warn "[[ Cooldown Triggered for user: #{user} ]]"
+      end
+    end
+  end
+end

data/lib/cinch/plugin/hooks.rb

@@ -0,0 +1,13 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  # An alteration to the Plugin Module to allow for configurable cooldowns.
+  module Plugin
+    # Add the pre hook to all messages triggered
+    module ClassMethods
+      def enforce_cooldown
+        hook(:pre, for: [:match],
+                   method: ->(m){ Cooldowns.finished?(m, shared[:cooldown], @bot) })
+      end
+    end
+  end
+end

data/spec/cinch-cooldown_spec.rb

@@ -12,71 +12,94 @@ class MyPlugin
 end
 
 def bot_for_cooldowns(global = 10, user = 0)
-  @bot = Cinch::Test::MockBot.new do
-           configure do |c|
-             c.nick = 'testbot'
-             c.server = nil
-             c.channels = ['foo']
-             c.reconnect = false
-             c.plugins.plugins = [MyPlugin]
-             c.shared[:cooldown] = { :config => { '#foo' => { :global => global, :user => user } } }
-           end
-         end
+  Cinch::Test::MockBot.new do
+    configure do |c|
+      c.nick = 'testbot'
+      c.server = nil
+      c.channels = ['foo']
+      c.reconnect = false
+      c.plugins.plugins = [MyPlugin]
+      c.shared[:cooldown] = { :config => { '#foo' => { :global => global, :user => user } } }
+    end
+  end
 end
 
-describe Cinch::Cooldown do
+describe Cinch::Cooldowns do
   include Cinch::Test
 
+  after(:each) do
+    Cinch::Plugin::Cooldowns.purge!
+  end
+
   it 'should not trigger cooldowns on private messages' do
-    @bot = bot_for_cooldowns(10)
-    get_replies(make_message(@bot, "!thing"))
-    get_replies(make_message(@bot, "!thing")).first.text.
+    bot = bot_for_cooldowns(10)
+    get_replies(make_message(bot, "!thing"))
+    get_replies(make_message(bot, "!thing")).first.text.
       should match "OMG"
   end
 
   it 'should allow plugins to mandate a global cooldown between responses in channel' do
-    @bot = bot_for_cooldowns(10)
-    get_replies(make_message(@bot, "!thing", channel: '#foo'))
-    get_replies(make_message(@bot, "!thing", channel: '#foo')).first.text.
-      should match(/Sorry, you'll have to wait \d+ seconds from now before I can talk/)
+    bot = bot_for_cooldowns(10)
+    get_replies(make_message(bot, "!thing", channel: '#foo'))
+    get_replies(make_message(bot, "!thing", channel: '#foo')).first.text.
+      should match(/Sorry, cooldown is in effect: \d+ seconds from now before/)
   end
 
   it 'should allow plugins allow responses after the global cooldown' do
-    @bot = bot_for_cooldowns(5)
-    get_replies(make_message(@bot, "!thing", channel: '#foo'))
-    sleep 5
-    get_replies(make_message(@bot, "!thing", channel: '#foo')).first.text.
+    bot = bot_for_cooldowns(5, 5)
+    get_replies(make_message(bot, "!thing", channel: '#foo'))
+    sleep 7
+    get_replies(make_message(bot, "!thing", channel: '#foo')).first.text.
       should == 'OMG'
   end
 
   it 'should allow plugins to mandate a minimum time between responses in channel' do
-    @bot = bot_for_cooldowns(5, 10)
-    get_replies(make_message(@bot, "!thing", channel: '#foo'))
-    sleep 6
-    get_replies(make_message(@bot, "!thing", channel: '#foo')).first.text.
-      should match(/Sorry, you'll have to wait \d+ seconds from now before you can use/)
+    bot = bot_for_cooldowns(5, 10)
+    get_replies(make_message(bot, "!thing", channel: '#foo'))
+    sleep 7
+    get_replies(make_message(bot, "!thing", channel: '#foo')).first.text.
+      should match(/Sorry, cooldown is in effect: \d+ seconds from now before you can use/)
   end
 
   it 'should allow plugins to mandate a minimum time between responses in channel' do
-    @bot = bot_for_cooldowns(5, 10)
-    get_replies(make_message(@bot, "!thing", channel: '#foo'))
-    sleep 10
-    get_replies(make_message(@bot, "!thing", channel: '#foo')).first.text.
+    bot = bot_for_cooldowns(5, 10)
+    get_replies(make_message(bot, "!thing", channel: '#foo'))
+    sleep 12
+    get_replies(make_message(bot, "!thing", channel: '#foo')).first.text.
+      should == 'OMG'
+  end
+
+  it 'should aplugins to mandate a minimum time between responses in channel' do
+    bot = bot_for_cooldowns(5, 10)
+    get_replies(make_message(bot, "!thing", channel: '#foo'))
+    get_replies(make_message(bot, "thing",  channel: '#foo'))
+    sleep 6
+    get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'george'))
+    sleep 5
+    get_replies(make_message(bot, "!thing", channel: '#foo')).first.text.
       should == 'OMG'
   end
 
   it 'should not trigger if the config for the current channel does not exist' do
-    @bot = bot_for_cooldowns(5, 10)
-    get_replies(make_message(@bot, "!thing", channel: '#bar'))
-    get_replies(make_message(@bot, "!thing", channel: '#bar')).first.text.
+    bot = bot_for_cooldowns(5, 10)
+    get_replies(make_message(bot, "!thing", channel: '#bar'))
+    get_replies(make_message(bot, "!thing", channel: '#bar')).first.text.
       should == 'OMG'
   end
 
-  it 'should trigger for other users if the global cooldown is not finished' do
-    @bot = bot_for_cooldowns(10, 20)
-    get_replies(make_message(@bot, "!thing", channel: '#foo', nick: 'test1')).first.text.
+  it 'should trigger for other users if the global cooldown is finished' do
+    bot = bot_for_cooldowns(0, 20)
+    get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test1')).first.text.
+      should == 'OMG'
+    sleep 1
+    get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test2')).first.text.
+      should == 'OMG'
+  end
+  it 'should trigger for other users if the global cooldown is finished' do
+    bot = bot_for_cooldowns(10, 20)
+    get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test1')).first.text.
       should == 'OMG'
-    get_replies(make_message(@bot, "!thing", channel: '#foo', nick: 'test2')).first.text.
+    get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test2')).first.text.
       should_not == 'OMG'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: cinch-cooldown
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.3
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2014-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -98,7 +98,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: 2.0.12
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
@@ -106,7 +106,7 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: 2.0.12
 description: This gem allows you to set a shared timer across plugins that are configured
   to respect it.
 email:
@@ -124,10 +124,14 @@ files:
 - cinch-cooldown.gemspec
 - lib/cinch/cooldown.rb
 - lib/cinch/cooldown/version.rb
+- lib/cinch/plugin/cooldown.rb
+- lib/cinch/plugin/cooldowns.rb
+- lib/cinch/plugin/hooks.rb
 - spec/cinch-cooldown_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/bhaberer/cinch-cooldown
-licenses: []
+licenses:
+- MIT
 post_install_message: 
 rdoc_options: []
 require_paths:
@@ -146,7 +150,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.25
 signing_key: 
 specification_version: 3
 summary: Global Cooldown tracker for Cinch Plugins