cinch-cooldown 1.0.1 → 1.2.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: afcb1d5bb660b10ac1afa239d53e5435203d5dad30f036541da1738a91fe4b3a
+  data.tar.gz: ff3853080487597ab97ed5b48741dc1f301b9886e1b75ae4ee702a913bfc6e24
+SHA512:
+  metadata.gz: 1e92a9a301068474704d8282036e4170c43ade682775de898c91107b6de3fd593657088a7b6ecdd7047002a571da2bfa1d2241928f12d054e6afe40199c5c2aa
+  data.tar.gz: 7ecd2247605653d190459fbd02ad97016e958dc0a7494ba543ca9119dbde4b014bfd00ac859aa2e4ce8e0e4243fc4af12c21da4d492b9e39ce7c8a70acbe8408

data/.travis.yml

@@ -1,4 +1,34 @@
+addons:
+    code_climate:
+        repo_token: 15db41183ecae7874c0ff86ec1e24b2c340f9a977ebb5f4f4c6421e4f82bd0de
 language: ruby
+before_install:
+  - gem update --system
+  - gem update bundler
+env:
+  global:
+    - "JRUBY_OPTS=-Xcext.enabled=true"
 rvm:
+  - 1.8.7
   - 1.9.2
   - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - 2.2.0
+  - 2.3.0
+  - jruby-18mode
+  - jruby-19mode
+  - ruby-head
+  - jruby-head
+  - ree
+matrix:
+  allow_failures:
+    - rvm: 1.8.7
+    - rvm: 1.9.2
+    - rvm: 1.9.3
+    - rvm: ree
+    - rvm: jruby-18mode
+    - rvm: jruby-19mode
+    - rvm: jruby-head
+    - rvm: ruby-head
+  fast_finish: true

data/README.md

@@ -1,10 +1,13 @@
+# Note: As of v1.2.0 the config changed to use symbols for the channel names, please be aware.
+
 # Cinch::Cooldown
 
 [![Gem Version](https://badge.fury.io/rb/cinch-cooldown.png)](http://badge.fury.io/rb/cinch-cooldown)
 [![Dependency Status](https://gemnasium.com/bhaberer/cinch-cooldown.png)](https://gemnasium.com/bhaberer/cinch-cooldown)
 [![Build Status](https://travis-ci.org/bhaberer/cinch-cooldown.png?branch=master)](https://travis-ci.org/bhaberer/cinch-cooldown)
-[![Coverage Status](https://coveralls.io/repos/bhaberer/cinch-cooldown/badge.png?branch=master)](https://coveralls.io/r/bhaberer/cinch-cooldown?branch=master)
-[![Code Climate](https://codeclimate.com/github/bhaberer/cinch-cooldown.png)](https://codeclimate.com/github/bhaberer/cinch-cooldown)
+[![Code Climate](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/badges/3a98b90ce443c23969c8/gpa.svg)](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/feed)
+[![Test Coverage](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/badges/3a98b90ce443c23969c8/coverage.svg)](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/coverage)
+[![Issue Count](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/badges/3a98b90ce443c23969c8/issue_count.svg)](https://codeclimate.com/repos/56aa7be85b34ac007f002f94/feed)
 
 This library is used to add a global cooldown so that users are prevented from spamming the
 channel.
@@ -30,14 +33,14 @@ 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.
+channel, while the `:user` directive is how long it will wait per user.
+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 } }
+    ```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
+this with your own plugins, you 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

@@ -4,24 +4,26 @@ $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.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.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.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.files = `git ls-files`.split($/)
+  gem.executables = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
+  gem.test_files = gem.files.grep(/^(test|spec|features)\//)
+  gem.require_paths = ['lib']
+  gem.license = 'MIT'
+  gem.required_ruby_version = '>= 2.0.0'
 
-  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', '~> 12.3.3'
+  gem.add_development_dependency 'rspec', '~> 3'
+  gem.add_development_dependency 'cinch-test', '~> 0.1', '>= 0.1.1'
+  gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.4'
 
-  gem.add_dependency    'time-lord',      '~> 1.0.1'
-  gem.add_dependency    'cinch',          '~> 2.0.5'
+  gem.add_dependency 'cinch', '~> 2'
+  gem.add_dependency 'time-lord', '~> 1.0', '>= 1.0.1'
 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.2.1'
   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,134 @@
+# -*- coding: utf-8 -*-
+module Cinch
+  module Plugin
+    # Class for managing the cooldown objects.
+    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?
+
+          channel = channel_to_key(m.channel.name)
+
+          clean_expired_cooldowns(channel)
+
+          # return true if the cooldowns have expired
+          return true if cool?(channel, m.user.nick)
+
+          # Otherwise message the user about unfinished cooldowns
+          m.user.notice message(channel, 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.channel_to_key(channel)
+        return channel if channel.is_a?(Symbol)
+        channel[/\w+/].to_sym
+      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|
+          @cooldowns[channel].delete(key) if cooldown.cooled_down?
+        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,14 @@
+# -*- 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

@@ -2,81 +2,111 @@ require 'spec_helper'
 
 class MyPlugin
   include Cinch::Plugin
-
   enforce_cooldown
-
-  match /thing/
+  match(/thing/)
   def execute(m)
     m.reply 'OMG'
   end
 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
+def bot_for_cooldowns(global: 10, user: 0, channel: 'foo')
+  Cinch::Test::MockBot.new do
+    configure do |c|
+      c.nick = 'testbot'
+      c.server = nil
+      c.channels = ['channel']
+      c.reconnect = false
+      c.plugins.plugins = [MyPlugin]
+      c.shared[:cooldown] = { config: { channel.to_sym => { global: global, user: user } } }
+    end
+  end
 end
 
-describe Cinch::Cooldown do
+describe Cinch::Cooldowns do
   include Cinch::Test
 
-  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.
-      should match "OMG"
+  after(:each) do
+    Cinch::Plugin::Cooldowns.purge!
   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/)
-  end
+  let(:bot) { bot_for_cooldowns }
 
-  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.
-      should == 'OMG'
+  context 'when sending the bot a pm' do
+    it 'do not trigger cooldowns' do
+      get_replies(make_message(bot, "!thing"))
+      reply = get_replies(make_message(bot, "!thing")).first.text
+      expect(reply).to match('OMG')
+    end
   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/)
+  context 'when using global cooldowns' do
+    it 'allows a global cooldown between responses in channel' do
+      get_replies(make_message(bot, "!thing", channel: '#foo'))
+      reply = get_replies(make_message(bot, "!thing", channel: '#foo')).first.text
+      expect(reply).to match(/Sorry, cooldown is in effect: \d+ seconds from now/)
+    end
+
+    it 'allows responses after the global cooldown expires' do
+      bot = bot_for_cooldowns(global: 5, user: 5)
+      get_replies(make_message(bot, "!thing", channel: '#foo'))
+      sleep 7
+      reply = get_replies(make_message(bot, "!thing", channel: '#foo')).first.text
+      expect(reply).to eq('OMG')
+    end
+
+    it 'triggers for other users if the global cooldown is finished' do
+      bot = bot_for_cooldowns(global: 0, user: 20)
+      reply_a = get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test1')).first.text
+      expect(reply_a).to eq('OMG')
+      sleep 1
+      reply_b = get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test2')).first.text
+      expect(reply_b).to eq('OMG')
+    end
+
+    it 'does not trigger for other users if the global cooldown is not finished' do
+      bot = bot_for_cooldowns(global: 10, user: 20)
+      reply_good = get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test1')).first.text
+      expect(reply_good).to eq('OMG')
+      reply_cool = get_replies(make_message(bot, "!thing", channel: '#foo', nick: 'test2')).first.text
+      expect(reply_cool).not_to eq('OMG')
+    end
   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.
-      should == 'OMG'
+  context 'when using user cooldowns' do
+    it 'does not allow users to use commands in the period between cooldowns' do
+      bot = bot_for_cooldowns(global: 5, user: 10)
+      get_replies(make_message(bot, "!thing", channel: '#foo'))
+      sleep 7
+      reply = get_replies(make_message(bot, "!thing", channel: '#foo')).first.text
+      expect(reply).to match(/Sorry, cooldown is in effect: \d+ seconds from now before you can use/)
+    end
+
+    it 'allows users to use commands after their cooldown period ends' do
+      bot = bot_for_cooldowns(global: 5, user: 10)
+      get_replies(make_message(bot, "!thing", channel: '#foo'))
+      sleep 12
+      reply = get_replies(make_message(bot, "!thing", channel: '#foo')).first.text
+      expect(reply).to eq('OMG')
+    end
   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.
-      should == 'OMG'
+  it 'manages mutiple users incurring simultaneous cooldowns' do
+    bot = bot_for_cooldowns(global: 5, user: 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
+    expect(get_replies(make_message(bot, "!thing", channel: '#foo')).first.text)
+      .to eq('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.
-      should == 'OMG'
-    get_replies(make_message(@bot, "!thing", channel: '#foo', nick: 'test2')).first.text.
-      should_not == 'OMG'
+  context 'when configuration issues arise' do
+    it 'does not trigger if the config for the current channel does not exist' do
+      bot = bot_for_cooldowns(global: 5, user: 10)
+      get_replies(make_message(bot, "!thing", channel: '#bar'))
+      expect(get_replies(make_message(bot, "!thing", channel: '#bar')).first.text)
+        .to eq('OMG')
+    end
   end
 end

data/spec/spec_helper.rb

@@ -1,11 +1,5 @@
-require 'coveralls'
-require 'simplecov'
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter[
-  SimpleCov::Formatter::HTMLFormatter,
-  Coveralls::SimpleCov::Formatter
-]
-SimpleCov.start
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
 
 require 'cinch/cooldown'
 require 'cinch/test'

metadata

@@ -1,112 +1,111 @@
 --- !ruby/object:Gem::Specification
 name: cinch-cooldown
 version: !ruby/object:Gem::Version
-  version: 1.0.1
-  prerelease: 
+  version: 1.2.1
 platform: ruby
 authors:
 - Brian Haberer
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2013-07-04 00:00:00.000000000 Z
+date: 2021-01-27 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
-  name: coveralls
+  name: cinch-test
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.1
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
 - !ruby/object:Gem::Dependency
-  name: cinch-test
+  name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
-  name: time-lord
+  name: cinch
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: '2'
 - !ruby/object:Gem::Dependency
-  name: cinch
+  name: time-lord
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ~>
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.5
+        version: '1.0'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.0.1
 description: This gem allows you to set a shared timer across plugins that are configured
   to respect it.
 email:
@@ -115,8 +114,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -124,33 +123,34 @@ 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: []
-post_install_message: 
+licenses:
+- MIT
+metadata: {}
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.0.0
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 1.8.24
-signing_key: 
-specification_version: 3
+rubygems_version: 3.2.6
+signing_key:
+specification_version: 4
 summary: Global Cooldown tracker for Cinch Plugins
 test_files:
 - spec/cinch-cooldown_spec.rb
 - spec/spec_helper.rb
-has_rdoc: