cinch-dicebag 1.0.10 → 1.0.11

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 !binary "U0hBMQ==":
-  metadata.gz: 03ffcf66f79f8ac4138c0616c87bdec979c8a68b
-  data.tar.gz: 2ffd9ee34d9838564ce75c3823645f4d6b8d6016
+  metadata.gz: d3e9da9b55919a8e302f89dc06454ba9f21a906e
+  data.tar.gz: 3299d3573675957103835f15b9bb8b257fe44cda
 SHA512:
-  metadata.gz: 28deec95c393d146cf89c89aa49f476838f5e23aa045217addfdb3fccd7fb8a553be9c669b3a160e6956c29da0e611190370a4d60ffc726b30a781febf5ba1d0
-  data.tar.gz: 63c0c078021222b79ebed0dd726c191d5e57eb3ee87799f6f94c767d41f106c4c3d65dd87cd415742e9ba218226df1c865ca1e744f5dfc164692f90c92cc9af6
+  metadata.gz: dc9f46e21fca7b2409ef821cc3e404b19618cb4a937d7b5ab08952072eef854de894b4ffec874d7b7f16522f0593decfec711c44d211e59d39716664678649e8
+  data.tar.gz: 777863cd4e71c574ff280dafbdadf3a1b5133b8849c27016eaa6be803e4679753b3851c6f2276740da4541e71e74b8f6c3497f05417851428f08d347a050143d

data/cinch-dicebag.gemspec

@@ -8,24 +8,21 @@ Gem::Specification.new do |gem|
   gem.version       = Cinch::Dicebag::VERSION
   gem.authors       = ['Brian Haberer']
   gem.email         = ['bhaberer@gmail.com']
-  gem.description   = %q{Cinch Plugin that allows uses in the channel to roll specific dice or roll a random assortment of dice to compete for high scores.}
-  gem.summary       = %q{Cinch Plugin: Dicebag and Dice rolls}
+  gem.description   = %q(Cinch Plugin that allows uses in the channel to roll specific dice or roll a random assortment of dice to compete for high scores.)
+  gem.summary       = %q(Cinch Plugin: Dicebag and Dice rolls)
   gem.homepage      = 'https://github.com/bhaberer/cinch-dicebag'
   gem.license       = 'MIT'
-
   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.executables   = gem.files.grep(/^bin\//).map { |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(/^(test|spec|features)\//)
   gem.require_paths = ['lib']
 
-  gem.add_development_dependency  'rake'
-  gem.add_development_dependency  'rspec'
-  gem.add_development_dependency  'coveralls'
-  gem.add_development_dependency  'cinch-test'
-
-  gem.add_dependency              'cinch',           '>= 2.0.12'
-  gem.add_dependency              'time-lord',       '~> 1.0.1'
-  gem.add_dependency              'cinch-cooldown',  '>= 1.1.1'
-  gem.add_dependency              'cinch-storage',   '~> 1.1.0'
-  gem.add_dependency              'cinch-toolbox',   '~> 1.1.0'
+  gem.add_development_dependency 'rake', '~> 10'
+  gem.add_development_dependency 'rspec', '~> 3'
+  gem.add_development_dependency 'coveralls', '~> 0.7'
+  gem.add_development_dependency 'cinch-test', '~> 0.1', '>= 0.1.0'
+  gem.add_dependency 'cinch', '~> 2'
+  gem.add_dependency 'cinch-cooldown', '~> 1.1', '>= 1.1.1'
+  gem.add_dependency 'cinch-storage', '~> 1.1'
+  gem.add_dependency 'cinch-toolbox', '~> 1.1'
 end

data/lib/cinch/plugins/dicebag.rb

@@ -5,93 +5,96 @@ require 'cinch/cooldown'
 require 'cinch/storage'
 require 'time-lord'
 
-module Cinch::Plugins
-  # Cinch Plugin to allow dice rolling.
-  class Dicebag
-    include Cinch::Plugin
-
-    enforce_cooldown
-
-    attr_accessor :storage
-
-    self.help = 'Roll a random bag of dice with .dicebag, you can also ' +
-                'use .roll (dice count)d(sides) to roll specific dice ' +
-                '(e.g. .roll 4d6 3d20)'
-
-    match /dicebag\z/,      method: :dicebag
-    match /dicebag stats/,  method: :stats
-    match /roll(?:\s(.*))/, method: :roll
-    match /roll\z/,         method: :roll
-
-    def initialize(*args)
-      super
-      @storage = Cinch::Storage.new(config[:filename] || 'yaml/dice.yml')
-      @bag = Bag.new({ 4 => 250, 6 => 500, 10 => 750, 20 => 1000 })
-    end
-
-    # Roll a random assortment of dice, total the rolls, and record the score.
-    # @param [String] nick Nickname of the user rolling.
-    # @param [Cinch::Channel] channel The Channel object where the roll took
-    #   place.
-    # @return [String] A description of the roll that took place
-    def dicebag(m)
-      return if Cinch::Toolbox.sent_via_private_message?(m)
-
-      @bag.roll
-
-      m.reply "#{m.user.nick} rolls a #{@bag.size} bag of dice totalling " +
-              "#{@bag.score}. " +
-              score_check(m.user.nick.downcase, m.channel.name, @bag.score)
-    end
-
-    def stats(m)
-      return if Cinch::Toolbox.sent_via_private_message?(m)
-
-      m.user.send 'Top ten dicebag rolls:'
-      top10 = top_ten_rolls(m.channel.name)
-      top10.each_with_index { |r, i| m.user.send "#{i + 1} - #{r.first} [#{r.last}]"}
-    end
-
-    # Roll a specific set of dice and return the pretty result
-    # @param [String] nick Nickname of the user rolling.
-    # @param [String] dice Space delimited string of dice to role.
-    #   (i.e. '6d12 4d20 d10'
-    # @return [String] String describing the dice that were rolled
-    def roll(m, dice = '1d20')
-      result = Die.roll(dice.split(' '))
-      result = "#{m.user.nick} rolls #{dice} totalling #{result}" if result.is_a?(Integer)
-
-      m.reply result
-    end
-
-    private
-
-    def top_ten_rolls(channel)
-      scores = @storage.data[channel].dup
-      scores.sort { |a, b| b[1][:score] <=> a[1][:score] }
-            .map { |s| [s.first, s.last[:score]] }[0..9]
-    end
-
-    # Score checker for Dicebag rolls. Checks a given user/channel/score
-    #   against the current high score for that user.
-    # @param [String] nick Nickname of the user who rolled the score.
-    # @param [String] channel Name of the channel where the roll was made.
-    # @param [Fixnum] score The score from the bag.
-    # @return [String] If the new score is higher, returns an announcement
-    #   to that effect, otherwise returns a blank string.
-    def score_check(nick, channel, score)
-      # If the chennel or nick are not already initialized, spin them up
-      @storage.data[channel] ||= {}
-      @storage.data[channel][nick] ||= { score: score, time: Time.now }
-
-      # Check and see if this is a higher score.
-      old = @storage.data[channel][nick]
-      return '' unless @storage.data[channel][nick][:score] < score
-
-      @storage.data[channel][nick] = { score: score, time: Time.now }
-      @storage.synced_save(@bot)
-      "A new high score! Their old high roll was #{old[:score]}, " +
-        "#{old[:time].ago.to_words}."
+module Cinch
+  module Plugins
+    # Cinch Plugin to allow dice rolling.
+    class Dicebag
+      include Cinch::Plugin
+
+      attr_accessor :storage
+
+      self.help = 'Roll a random bag of dice with .dicebag, you can also ' \
+                  'use .roll (dice count)d(sides) to roll specific dice ' \
+                  '(e.g. .roll 4d6 3d20)'
+
+      match(/dicebag\z/, method: :dicebag)
+      match(/dicebag stats/, method: :stats)
+      match /roll(?:\s(.*))/, method: :roll
+      match /roll\z/, method: :roll
+
+      def initialize(*args)
+        super
+        @storage = Cinch::Storage.new(config[:filename] || 'yaml/dice.yml')
+        @bag = Bag.new(4 => 250, 6 => 500, 10 => 750, 20 => 1000)
+      end
+
+      # Roll a random assortment of dice, total the rolls, and record the score.
+      # @param [String] nick Nickname of the user rolling.
+      # @param [Cinch::Channel] channel The Channel object where the roll took
+      #   place.
+      # @return [String] A description of the roll that took place
+      def dicebag(m)
+        return if Cinch::Toolbox.sent_via_private_message?(m)
+
+        @bag.roll
+        user = m.user.nick.downcase
+        channel = m.channel.name
+        m.reply "#{m.user.nick} rolls a #{@bag.size} bag of dice totalling " \
+                "#{@bag.score}. #{score_check(user, channel, @bag.score)}"
+      end
+
+      def stats(m)
+        return if Cinch::Toolbox.sent_via_private_message?(m)
+
+        m.user.send 'Top ten dicebag rolls:'
+        top10 = top_ten_rolls(m.channel.name)
+        top10.each_with_index do |r, i|
+          m.user.send "#{i + 1} - #{r.first} [#{r.last}]"
+        end
+      end
+
+      # Roll a specific set of dice and return the pretty result
+      # @param [String] nick Nickname of the user rolling.
+      # @param [String] dice Space delimited string of dice to role.
+      #   (i.e. '6d12 4d20 d10'
+      # @return [String] String describing the dice that were rolled
+      def roll(m, dice = '1d20')
+        result = Die.roll(dice.split(' '))
+        if result.is_a?(Integer)
+          result = "#{m.user.nick} rolls #{dice} totalling #{result}"
+        end
+        m.reply result
+      end
+
+      private
+
+      def top_ten_rolls(channel)
+        scores = @storage.data[channel].dup
+        scores.sort { |a, b| b[1][:score] <=> a[1][:score] }
+              .map { |s| [s.first, s.last[:score]] }[0..9]
+      end
+
+      # Score checker for Dicebag rolls. Checks a given user/channel/score
+      #   against the current high score for that user.
+      # @param [String] nick Nickname of the user who rolled the score.
+      # @param [String] channel Name of the channel where the roll was made.
+      # @param [Fixnum] score The score from the bag.
+      # @return [String] If the new score is higher, returns an announcement
+      #   to that effect, otherwise returns a blank string.
+      def score_check(nick, channel, score)
+        # If the chennel or nick are not already initialized, spin them up
+        @storage.data[channel] ||= {}
+        @storage.data[channel][nick] ||= { score: score, time: Time.now }
+
+        # Check and see if this is a higher score.
+        old = @storage.data[channel][nick]
+        return '' unless @storage.data[channel][nick][:score] < score
+
+        @storage.data[channel][nick] = { score: score, time: Time.now }
+        @storage.synced_save(@bot)
+        "A new high score! Their old high roll was #{old[:score]}, " \
+          "#{old[:time].ago.to_words}."
+      end
     end
   end
 end

data/lib/cinch/plugins/dicebag/bag.rb

@@ -1,46 +1,49 @@
-module Cinch::Plugins
-  class Dicebag
-    class Bag
-      attr_accessor :count, :dice, :score
-      def initialize(dice_hash)
-        fail unless good_hash?(dice_hash)
-        @dice = dice_hash
-        @count = 0
-        @score = 0
-      end
+module Cinch
+  module Plugins
+    class Dicebag
+      # Class to handle rolling of a preset bag of dice.
+      class Bag
+        attr_accessor :count, :dice, :score
+        def initialize(dice_hash)
+          fail unless good_hash?(dice_hash)
+          @dice = dice_hash
+          @count = 0
+          @score = 0
+        end
 
-      def roll
-        dice = die_array
-        @score = Die.roll(dice)
-        @count = dice.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
-      end
+        def roll
+          dice = die_array
+          @score = Die.roll(dice)
+          @count = dice.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
+        end
 
-      def good_hash?(dice_hash)
-        dice_hash.keys { |k| return false unless k.is_a?(Integer) }
-        dice_hash.values { |k| return false unless k.is_a?(Integer) }
-        true
-      end
+        def good_hash?(dice_hash)
+          dice_hash.keys { |k| return false unless k.is_a?(Integer) }
+          dice_hash.values { |k| return false unless k.is_a?(Integer) }
+          true
+        end
 
-      # Simple method to return a flavor text 'size' description based on
-      #   how many dice you happened to get in your dicebag roll.
-      # @param [Fixnum] size The number of dice in the dicebag.
-      # @return [String] Description of the size of the bag.
-      def size
-        case count
-        when 0..100     then 'tiny'
-        when 101..500   then 'small'
-        when 501..1000  then 'medium'
-        when 1001..1500 then 'large'
-        when 1501..2000 then 'hefty'
-        else 'huge'
+        # Simple method to return a flavor text 'size' description based on
+        #   how many dice you happened to get in your dicebag roll.
+        # @param [Fixnum] size The number of dice in the dicebag.
+        # @return [String] Description of the size of the bag.
+        def size
+          case count
+          when 0..100     then 'tiny'
+          when 101..500   then 'small'
+          when 501..1000  then 'medium'
+          when 1001..1500 then 'large'
+          when 1501..2000 then 'hefty'
+          else 'huge'
+          end
         end
-      end
 
-      private
+        private
 
-      def die_array
-        @dice.keys.map do |sides|
-          "#{sides}d#{@dice[sides]}"
+        def die_array
+          @dice.keys.map do |sides|
+            "#{sides}d#{@dice[sides]}"
+          end
         end
       end
     end

data/lib/cinch/plugins/dicebag/die.rb

@@ -1,77 +1,87 @@
-module Cinch::Plugins
-  class Dicebag
-    module Die
-      MOD_REGEX = /[\-\+]\d+/
-      ROLLS_REGEX = /(\d+)d\d+/
-      SIDES_REGEX = /\d?d(\d+)/
-
-      # Takes a dice roll string or Array of dice rolls, sanitizes them, parses
-      # them, and dispatches their calculation to `Die.cast`.
-      # @param [Array] dice Array of strings that correspond to valid die rolls.
-      #   (i.e. ['4d6', '6d10']
-      # @return [Fixnum] The total from rolling all of the dice.
-      def self.roll(dice)
-        # Convert to an array if it's a single die roll
-        dice = [dice] if dice.is_a?(String)
-
-        # Clean out anything invalid
-        dice = clean_roll(dice)
-
-        total = nil
-
-        # Return if the sanity fails
-        return 'I don\'t have that many dice in my bag!' unless die_check?(dice)
-
-        # Roll each group and total up the returned value
-        dice.each do |die|
-          total ||= 0
-          total += cast(die)
+module Cinch
+  module Plugins
+    class Dicebag
+      # Module to manage the actuall roling of specific dice.
+      module Die
+        MOD_REGEX = /[\-\+]\d+/
+        ROLLS_REGEX = /(\d+)d\d+/
+        SIDES_REGEX = /\d?d(\d+)/
+
+        # Takes a dice roll string or Array of dice rolls, sanitizes them,
+        #   parses them, and dispatches their calculation to `Die.cast`.
+        # @param [Array] dice Array of strings that correspond to valid die
+        #   rolls. (i.e. ['4d6', '6d10']
+        # @return [Fixnum] The total from rolling all of the dice.
+        def self.roll(dice)
+          # Convert to an array if it's a single die roll
+          dice = [dice] if dice.is_a?(String)
+
+          # Clean out anything invalid
+          dice = clean_roll(dice)
+
+          total = nil
+
+          # Return if the sanity fails
+          return 'I don\'t have that many dice!' unless die_check?(dice)
+
+          # Roll each group and total up the returned value
+          dice.each do |die|
+            total ||= 0
+            total += cast(die)
+          end
+
+          total
         end
 
-        total
-      end
-
-      private
+        private
 
-      # Rolls an n-sided die a given amount of times and returns the total
-      # @param [String] count Number of times to roll the die.
-      # @return [Fixnum] The total from rolling the die.
-      def self.cast(die)
-        modifier = die[MOD_REGEX]
+        # Rolls an n-sided die a given amount of times and returns the total
+        # @param [String] count Number of times to roll the die.
+        # @return [Fixnum] The total from rolling the die.
+        def self.cast(die)
+          modifier = die[MOD_REGEX]
+          count = (die[ROLLS_REGEX, 1] || 1).to_i
+          sides = die[SIDES_REGEX, 1].to_i
 
-        count = (die[ROLLS_REGEX, 1] || 1).to_i
-        sides = die[SIDES_REGEX, 1].to_i
+          total = 0
+          return total unless check_die_sanity(count, sides)
 
-        return 0 if count.nil? || sides.nil? || sides < 1 || count < 1
+          count.times { total += rand(sides) + 1 }
 
-        total = 0
-        count.times { total += rand(sides) + 1 }
+          return total += parse_modifier(modifier) unless modifier.nil?
 
-        return total += parse_modifier(modifier) unless modifier.nil?
+          total
+        end
 
-        total
-      end
+        def self.check_die_sanity(count, sides)
+          return false if count.nil? || sides.nil? || sides < 1 || count < 1
+          true
+        end
 
-      def self.clean_roll(dice)
-        dice.delete_if { |d| d.match(/\d*d\d+([\-\+]\d+)?/).nil? }
-        dice
-      end
+        def self.clean_roll(dice)
+          dice.delete_if { |d| d.match(/\d*d\d+([\-\+]\d+)?/).nil? }
+          dice
+        end
 
-      # Takes an array of rolls and does sanity on it.
-      # @param [Array] dice Array of strings that correspond to valid die rolls.
-      #   (i.e. ['4d6', '6d10']
-      # @return [Boolean] Result of sanity check.
-      def self.die_check?(dice_list)
-        # Check to make sure it's not a stupid large roll, they clog threads.
-        count = dice_list.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
-        return false if count >= 10_000
-        true
-      end
+        # Takes an array of rolls and does sanity on it.
+        # @param [Array] dice Array of strings that correspond to valid
+        #   die rolls. (i.e. ['4d6', '6d10']
+        # @return [Boolean] Result of sanity check.
+        def self.die_check?(dice_list)
+          # Check to make sure it's not a stupid large roll, they clog threads.
+          count =
+            dice_list.map do |d|
+              d[/(\d+)d\d+/, 1].to_i || 1
+            end.inject(0, :+)
+          return false if count >= 10_000
+          true
+        end
 
-      def self.parse_modifier(modifier)
-        operator = modifier[/\A[\+\-]/]
-        int = modifier[/\d+\z/].to_i
-        0.send(operator, int)
+        def self.parse_modifier(modifier)
+          operator = modifier[/\A[\+\-]/]
+          int = modifier[/\d+\z/].to_i
+          0.send(operator, int)
+        end
       end
     end
   end

data/lib/cinch/plugins/dicebag/version.rb

@@ -2,6 +2,6 @@
 module Cinch
   # Versioning information for plugin
   module Dicebag
-    VERSION = '1.0.10'
+    VERSION = '1.0.11'
   end
 end

data/spec/cinch-dicebag_spec.rb

@@ -9,80 +9,82 @@ describe Cinch::Plugins::Dicebag do
 
   describe 'rolling specific dice' do
     it 'should return a roll from rolling dice' do
-      get_replies(make_message(@bot, '!roll 3d3', { nick: 'ted' })).first.
-        should_not be_nil
+      message = get_replies(make_message(@bot, '!roll 3d3', { nick: 'ted' }))
+      expect(message.first)
+        .to_not be_nil
     end
 
     it 'should return a roll from using a blank roll' do
-      get_replies(make_message(@bot, '!roll', { nick: 'ted' })).first.
-        should_not be_nil
+      expect(get_replies(make_message(@bot, '!roll', { nick: 'ted' })).first)
+        .to_not be_nil
     end
 
     it 'should allow "+" modifiers' do
-      roll = get_replies(make_message(@bot, '!roll 1d3+5', { nick: 'ted' })).first.text
+      roll = get_replies(make_message(@bot, '!roll 1d3+5', { nick: 'ted' }))
+               .first.text
       roll = roll[/totalling (\d+)/, 1]
-      (6..8).should include roll.to_i
+      expect(6..8).to include(roll.to_i)
     end
 
     it 'should allow "-" modifiers' do
       roll = get_replies(make_message(@bot, '!roll 1d1-5', { nick: 'ted' }))
               .first
               .text[/totalling (\-?\d+)/, 1].to_i
-              .should == -4
+      expect(roll).to eq(-4)
     end
 
     it 'should return a roll in bounds from rolling dice' do
       roll = get_replies(make_message(@bot, '!roll 3d3', { nick: 'ted' })).first.text
       roll = roll[/totalling (\d+)/, 1]
-      (3..9).should include roll.to_i
+      expect(3..9).to include(roll.to_i)
     end
 
     it 'should disallow rolling stupid numbers of dice' do
-      get_replies(make_message(@bot, '!roll 100001d20', { nick: 'ted' })).first.
-        should include 'I don\'t have that many dice in my bag!'
+      expect(get_replies(make_message(@bot, '!roll 100001d20', { nick: 'ted' })).first.text)
+        .to include('I don\'t have that many dice!')
     end
 
     it 'should disallow rolling stupid numbers of dice (multiple dice types)' do
-      get_replies(make_message(@bot, '!roll 5000d3 5000d20 1d30', { nick: 'ted' })).first.
-        should include 'I don\'t have that many dice in my bag!'
+      expect(get_replies(make_message(@bot, '!roll 5000d3 5000d20 1d30', { nick: 'ted' })).first.text)
+        .to include('I don\'t have that many dice!')
     end
 
     it 'should return a roll from rolling mixes of dice' do
-      get_replies(make_message(@bot, '!roll 3d3 d7 3d21', { nick: 'ted' })).first.
-        should_not be_nil
+      expect(get_replies(make_message(@bot, '!roll 3d3 d7 3d21', { nick: 'ted' })).first)
+        .to_not be_nil
     end
 
     it 'should return a roll in bounds from rolling mixes of dice' do
       roll = get_replies(make_message(@bot, '!roll 3d3 d7 3d21', { nick: 'ted' })).first.text
       roll = roll[/totalling (\d+)/, 1]
-      (7..79).should include roll.to_i
+      expect(7..79).to include(roll.to_i)
     end
 
     it 'should return a roll from rolling a single die' do
-      get_replies(make_message(@bot, '!roll d3', { nick: 'ted' })).first.
-        should_not be_nil
+      expect(get_replies(make_message(@bot, '!roll d3', { nick: 'ted' })).first)
+        .to_not be_nil
     end
 
     it 'should return a string describing the dice that were rolled' do
       text = get_replies(make_message(@bot, '!roll 3d3', { nick: 'ted' })).first.text
-      text.should match(/rolls\s3d3\stotalling\s\d+/)
+      expect(text).to match(/rolls\s3d3\stotalling\s\d+/)
     end
   end
 
   describe 'roll_dicebag' do
     it 'should return a string' do
-      get_replies(make_message(@bot, '!dicebag' , { nick: 'ted', channel: '#bar' })).first.
-        should_not be_nil
+      expect(get_replies(make_message(@bot, '!dicebag' , { nick: 'ted', channel: '#bar' })).first)
+        .to_not be_nil
     end
 
     it 'should return an error if the user is not in a channel' do
-      get_replies(make_message(@bot, '!dicebag' , { nick: 'ted' })).first.text.
-        should == 'You must use that command in the main channel.'
+      expect(get_replies(make_message(@bot, '!dicebag' , { nick: 'ted' })).first.text)
+        .to eq('You must use that command in the main channel.')
     end
 
     it 'should return a string describing the user\'s bag roll' do
-      get_replies(make_message(@bot, '!dicebag' , { nick: 'ted', channel: '#bar' })).first.text.
-        should match(/ted rolls a [a-z]+ bag of dice totalling \d+/)
+      expect(get_replies(make_message(@bot, '!dicebag' , { nick: 'ted', channel: '#bar' })).first.text)
+        .to match(/ted rolls a [a-z]+ bag of dice totalling \d+/)
     end
   end
 
@@ -107,59 +109,59 @@ describe Cinch::Plugins::Dicebag do
 
     it 'should announce a high score if the old score is higher' do
       text = get_replies(make_message(@bot, '!dicebag' , { nick: 'brian', channel: '#foo' })).first.text
-      text.should match(/A new high score/)
-      text.should match(/Their old high roll was \d+/)
+      expect(text).to match(/A new high score/)
+      expect(text).to match(/Their old high roll was \d+/)
     end
 
     it 'should allow users to get a copy of the high scores' do
       replies = get_replies(make_message(@bot, '!dicebag stats' , { nick: 'brian', channel: '#foo' }))
-      replies[1].text.should == '1 - omega [15]'
-      replies[5].text.should == '5 - grill [11]'
+      expect(replies[1].text).to eq('1 - omega [15]')
+      expect(replies[5].text).to eq('5 - grill [11]')
     end
 
     it 'should only show the first 10 scores' do
       replies = get_replies(make_message(@bot, '!dicebag stats' , { nick: 'brian', channel: '#foo' }))
-      replies.length.should == 11
+      expect(replies.length).to eq(11)
     end
   end
 
   describe 'roll_dice' do
     it 'should return nil if the dice list is empty' do
-      Cinch::Plugins::Dicebag::Die.roll([]).should be_nil
+      expect(Cinch::Plugins::Dicebag::Die.roll([])).to be_nil
     end
 
     it 'should return a non zero total on a normal dice list' do
-      Cinch::Plugins::Dicebag::Die.roll(['3d3', '4d5']).should_not be_zero
+      expect(Cinch::Plugins::Dicebag::Die.roll(['3d3', '4d5'])).to_not be_zero
     end
 
     it 'should clear out any invalid dice rolls' do
-      Cinch::Plugins::Dicebag::Die.roll(['33']).should be_nil
+      expect(Cinch::Plugins::Dicebag::Die.roll(['33'])).to be_nil
     end
 
     it 'should allow modifiers' do
-      Cinch::Plugins::Dicebag::Die.roll(['1d1+1', '1d1-4']).should == -1
+      expect(Cinch::Plugins::Dicebag::Die.roll(['1d1+1', '1d1-4'])).to eq(-1)
     end
   end
 
   describe 'Die.roll' do
     it 'should return an acceptable value for a given roll' do
-      Cinch::Plugins::Dicebag::Die.roll('1d1').should == 1
-      (3..15).should include(Cinch::Plugins::Dicebag::Die.roll('3d5'))
+      expect(Cinch::Plugins::Dicebag::Die.roll('1d1')).to eq(1)
+      expect(3..15).to include(Cinch::Plugins::Dicebag::Die.roll('3d5'))
     end
 
     it 'should return nil for any negetive values' do
-      Cinch::Plugins::Dicebag::Die.roll('1d-1').should == nil
-      Cinch::Plugins::Dicebag::Die.roll('-1d-1').should == nil
+      expect(Cinch::Plugins::Dicebag::Die.roll('1d-1')).to eq(nil)
+      expect(Cinch::Plugins::Dicebag::Die.roll('-1d-1')).to eq(nil)
     end
 
     it 'should add modifiers to the total' do
-      Cinch::Plugins::Dicebag::Die.roll('1d1+2').should == 3
-      Cinch::Plugins::Dicebag::Die.roll('3d1-2').should == 1
+      expect(Cinch::Plugins::Dicebag::Die.roll('1d1+2')).to eq(3)
+      expect(Cinch::Plugins::Dicebag::Die.roll('3d1-2')).to eq(1)
     end
 
     it 'should allow modifiers to take the total below zero' do
-      Cinch::Plugins::Dicebag::Die.roll('1d1-1').should == 0
-      Cinch::Plugins::Dicebag::Die.roll('1d1-2').should == -1
+      expect(Cinch::Plugins::Dicebag::Die.roll('1d1-1')).to eq(0)
+      expect(Cinch::Plugins::Dicebag::Die.roll('1d1-2')).to eq(-1)
     end
   end
 
@@ -170,92 +172,92 @@ describe Cinch::Plugins::Dicebag do
 
     it 'should return \'huge\' for out of bounds queries' do
       @bag.count = 50000
-      @bag.size.should == 'huge'
+      expect(@bag.size).to eq('huge')
     end
 
     it 'should return the proper size for tiny range' do
       @bag.count = 0
-      @bag.size.should == 'tiny'
+      expect(@bag.size).to eq('tiny')
     end
 
     it 'should return the proper size for small range' do
       @bag.count = rand(100)
-      @bag.size.should == 'tiny'
+      expect(@bag.size).to eq('tiny')
     end
 
     it 'should return the proper size for small range' do
       @bag.count = 100
-      @bag.size.should == 'tiny'
+      expect(@bag.size).to eq('tiny')
     end
 
     it 'should return the proper size for small range' do
       @bag.count = 101
-      @bag.size.should == 'small'
+      expect(@bag.size).to eq('small')
     end
 
     it 'should return the proper size for small range' do
       @bag.count = rand(399) + 101
-      @bag.size.should == 'small'
+      expect(@bag.size).to eq('small')
     end
 
     it 'should return the proper size for small range' do
       @bag.count = 500
-      @bag.size.should == 'small'
+      expect(@bag.size).to eq('small')
     end
 
     it 'should return the proper size for medium range' do
       @bag.count = 501
-      @bag.size.should == 'medium'
+      expect(@bag.size).to eq('medium')
     end
 
     it 'should return the proper size for medium range' do
       @bag.count = rand(499) + 501
-      @bag.size.should == 'medium'
+      expect(@bag.size).to eq('medium')
     end
 
     it 'should return the proper size for medium range' do
       @bag.count = 1000
-      @bag.size.should == 'medium'
+      expect(@bag.size).to eq('medium')
     end
 
     it 'should return the proper size for large range' do
       @bag.count = 1001
-      @bag.size.should == 'large'
+      expect(@bag.size).to eq('large')
     end
 
     it 'should return the proper size for large range' do
       @bag.count = rand(499) + 1001
-      @bag.size.should == 'large'
+      expect(@bag.size).to eq('large')
     end
 
     it 'should return the proper size for large range' do
       @bag.count = 1500
-      @bag.size.should == 'large'
+      expect(@bag.size).to eq('large')
     end
 
     it 'should return the proper size for hefty range' do
       @bag.count = 1501
-      @bag.size.should == 'hefty'
+      expect(@bag.size).to eq('hefty')
     end
 
     it 'should return the proper size for hefty range' do
       @bag.count = rand(499) + 1501
-      @bag.size.should == 'hefty'
+      expect(@bag.size).to eq('hefty')
     end
 
     it 'should return the proper size for hefty range' do
       @bag.count = 2000
-      @bag.size.should == 'hefty'
+      expect(@bag.size).to eq('hefty')
     end
 
     it 'should return the proper size for huge range' do
       @bag.count = 2001
-      @bag.size.should == 'huge'
+      expect(@bag.size).to eq('huge')
     end
 
     it 'should return the proper size for huge range' do
       @bag.count = 20001
-      @bag.size.should == 'huge'
+      expect(@bag.size).to eq('huge')
     end
   end
 end

metadata

@@ -1,103 +1,98 @@
 --- !ruby/object:Gem::Specification
 name: cinch-dicebag
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.11
 platform: ruby
 authors:
 - Brian Haberer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-22 00:00:00.000000000 Z
+date: 2014-07-30 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '10'
 - !ruby/object:Gem::Dependency
   name: rspec
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '3'
 - !ruby/object:Gem::Dependency
   name: coveralls
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.7'
 - !ruby/object:Gem::Dependency
   name: cinch-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.1'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 0.1.0
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: '0'
-- !ruby/object:Gem::Dependency
-  name: cinch
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
+    - - ~>
       - !ruby/object:Gem::Version
-        version: 2.0.12
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
+        version: '0.1'
     - - ! '>='
       - !ruby/object:Gem::Version
-        version: 2.0.12
+        version: 0.1.0
 - !ruby/object:Gem::Dependency
-  name: time-lord
+  name: cinch
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: '2'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.0.1
+        version: '2'
 - !ruby/object:Gem::Dependency
   name: cinch-cooldown
   requirement: !ruby/object:Gem::Requirement
     requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.1.1
@@ -105,6 +100,9 @@ dependencies:
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
     - - ! '>='
       - !ruby/object:Gem::Version
         version: 1.1.1
@@ -114,28 +112,28 @@ dependencies:
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: cinch-toolbox
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
-        version: 1.1.0
+        version: '1.1'
 description: Cinch Plugin that allows uses in the channel to roll specific dice or
   roll a random assortment of dice to compete for high scores.
 email: