cinch-dicebag 1.0.10 → 1.0.15

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-!binary "U0hBMQ==":
-  metadata.gz: 03ffcf66f79f8ac4138c0616c87bdec979c8a68b
-  data.tar.gz: 2ffd9ee34d9838564ce75c3823645f4d6b8d6016
+SHA256:
+  metadata.gz: 737d5d1176e002405d852c856b4355a0c4454a548f20fef8e557ab6b566ccec9
+  data.tar.gz: 2d7035798fee93df2b368ec31db1ddd97c300e82514f12c0ad0f9a30faa4a876
 SHA512:
-  metadata.gz: 28deec95c393d146cf89c89aa49f476838f5e23aa045217addfdb3fccd7fb8a553be9c669b3a160e6956c29da0e611190370a4d60ffc726b30a781febf5ba1d0
-  data.tar.gz: 63c0c078021222b79ebed0dd726c191d5e57eb3ee87799f6f94c767d41f106c4c3d65dd87cd415742e9ba218226df1c865ca1e744f5dfc164692f90c92cc9af6
+  metadata.gz: 2da4e8c8a2aff23a3be079d2a4dcb0070d4ae5e21bf2364a4063b0c664b7d3a1f7ab4c9ecfca51688ff90cb92b42c6bb6aff5c1ee61381bfc1b1161ea76d6dd5
+  data.tar.gz: afa3c62c79b51daf4f36e9213a50ff4d4240d5484feb1070ef831aeda79086685836d9ff02726f87f8699663111ed3d8772e74b8396a5d7a5154aa2162aa0e7c

data/.travis.yml

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

data/cinch-dicebag.gemspec

@@ -8,24 +8,22 @@ 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_development_dependency 'rake', '~> 12.3.3'
+  gem.add_development_dependency 'rspec', '~> 3'
+  gem.add_development_dependency 'codeclimate-test-reporter', '~> 0.4'
+  gem.add_development_dependency 'cinch-test', '~> 0.1', '>= 0.1.1'
 
-  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_dependency 'cinch', '~> 2'
+  gem.add_dependency 'cinch-cooldown', '~> 1.1', '>= 1.1.5'
+  gem.add_dependency 'cinch-storage', '~> 1.1'
+  gem.add_dependency 'cinch-toolbox', '~> 1.1'
 end

data/lib/cinch/plugins/dicebag.rb

@@ -5,93 +5,101 @@ 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
+
+      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
+        # initialize storage
+        @storage = Cinch::Storage.new(config[:filename] || 'yaml/dice.yml')
+
+        # Create a bag of dice, pass a hash of the maxcount for each type
+        #   for random rolls.
+        @bag = Bag.new(4 => 250, 6 => 750, 10 => 1500, 20 => 2000)
+      end
+
+      # Roll a random assortment of dice, total the rolls, and record the score.
+      # @param [Message] message Nickname of the user rolling.
+      # @return [String] A description of the roll that took place
+      def dicebag(message)
+        return if Cinch::Toolbox.sent_via_private_message?(message)
+
+        @bag.roll
+        user = message.user.nick
+        channel = message.channel.name
+        message.reply "#{user} rolls a #{@bag.size} bag of dice totalling " \
+                      "#{@bag.score}. #{score_check(user, channel, @bag.score)}"
+      end
+
+      def stats(message)
+        return if Cinch::Toolbox.sent_via_private_message?(message)
+
+        message.user.send 'Top ten dicebag rolls:'
+        top10 = top_ten_rolls(message.channel.name)
+        top10.each_with_index do |r, i|
+          message.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(message, dice = '1d20')
+        result = Die.roll(dice.split(' '))
+        if result.is_a?(Integer)
+          result = "#{message.user.nick} rolls #{dice} totalling #{result}"
+        end
+        message.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)
+        nick = nick.downcase
+        # 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,72 @@
-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 roll
-        dice = die_array
-        @score = Die.roll(dice)
-        @count = dice.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
-      end
+        # Create a new bag
+        # @param [Hash] dice_hash Hash of dice, in the format of
+        #   { :num_sides => :max_dice_to_roll, ... }
+        #   The bag will randomly roll (1-:max_dice_to_roll) :num_sided dice.
+        def initialize(dice_hash)
+          fail unless good_hash?(dice_hash)
+          @dice = dice_hash
+          @count = 0
+          @score = 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 stats
+          max_score = @dice.keys.inject(0) { |sum, x| sum + (x * @dice[x]) }
+          min_score = @dice.keys.count
+          max_count = @dice.values.inject(0) { |sum, x| sum + x }
+          min_count = @dice.keys.count
+          { min_count: min_count, max_count: max_count,
+            min_score: min_score, max_score: max_score }
+        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'
+        # Roll the bag of dice, this will roll the dice and update the current
+        #   score and count
+        def roll
+          dice = die_array
+          @score = Die.roll(dice)
+          @count = dice.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
+          return self
+        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
+          when @count < 1000 then 'tiny'
+          when @count < 2000 then 'small'
+          when @count < 3000 then 'medium'
+          when @count < 4000 then 'large'
+          when @count < 5000 then 'hefty'
+          else 'massive'
+          end
         end
-      end
 
-      private
+        private
+
+        # Check to make sure that the passed hash of dice looks basically
+        #   reasonable.
+        # e.g. { 4 => 10, 6 => 20, 100 => 20 }
+        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 die_array
-        @dice.keys.map do |sides|
-          "#{sides}d#{@dice[sides]}"
+        # Render the @dice hash as an array of rolls to pass to the Die module.
+        #   This also is where we randomly select how many dice from the range
+        #   are actually rolled.
+        def die_array
+          @dice.keys.map do |sides|
+            "#{rand(@dice[sides] + 1)}d#{sides}"
+          end
         end
       end
     end

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

@@ -1,77 +1,92 @@
-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)
+
+          # Initialize a total
+          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
+        # 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)
+          # Pull out the data from the roll. 
+          modifier = die[MOD_REGEX]
+          count = (die[ROLLS_REGEX, 1] || 1).to_i
+          sides = die[SIDES_REGEX, 1].to_i
 
-      # 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]
+          # init the total
+          total = 0
 
-        count = (die[ROLLS_REGEX, 1] || 1).to_i
-        sides = die[SIDES_REGEX, 1].to_i
+          # Bail if the roll isn't sane looking.
+          return total unless check_die_sanity(count, sides)
 
-        return 0 if count.nil? || sides.nil? || sides < 1 || count < 1
+          # Roll dem dice!
+          count.times { total += rand(sides) + 1 }
 
-        total = 0
-        count.times { total += rand(sides) + 1 }
+          # Parse the modifier and apply it, if there is one
+          return total += parse_modifier(modifier) unless modifier.nil?
 
-        return total += parse_modifier(modifier) unless modifier.nil?
+          total
+        end
 
-        total
-      end
+        # Makes sure people aren't doing silly things.
+        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
+        # Remove any stupid crap people try to sneak into the rolls.
+        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)
+          # Check to make sure it's not a stupid large roll, they clog threads.
+          count = dice.map { |d| d[/(\d+)d\d+/, 1].to_i || 1 }.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)
+        # Parse out the modified and return it as an 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.15'
   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('massive')
     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'
+      @bag.count = rand(1000)
+      expect(@bag.size).to eq('tiny')
     end
 
     it 'should return the proper size for small range' do
-      @bag.count = 100
-      @bag.size.should == 'tiny'
+      @bag.count = 900
+      expect(@bag.size).to eq('tiny')
     end
 
     it 'should return the proper size for small range' do
-      @bag.count = 101
-      @bag.size.should == 'small'
+      @bag.count = 1000
+      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'
+      @bag.count = rand(999) + 1000
+      expect(@bag.size).to eq('small')
     end
 
     it 'should return the proper size for small range' do
-      @bag.count = 500
-      @bag.size.should == 'small'
+      @bag.count = 1999
+      expect(@bag.size).to eq('small')
     end
 
     it 'should return the proper size for medium range' do
-      @bag.count = 501
-      @bag.size.should == 'medium'
+      @bag.count = 2500
+      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'
+      @bag.count = rand(999) + 2000
+      expect(@bag.size).to eq('medium')
     end
 
     it 'should return the proper size for medium range' do
-      @bag.count = 1000
-      @bag.size.should == 'medium'
+      @bag.count = 2500
+      expect(@bag.size).to eq('medium')
     end
 
     it 'should return the proper size for large range' do
-      @bag.count = 1001
-      @bag.size.should == 'large'
+      @bag.count = 3500
+      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'
+      @bag.count = rand(999) + 3000
+      expect(@bag.size).to eq('large')
     end
 
     it 'should return the proper size for large range' do
-      @bag.count = 1500
-      @bag.size.should == 'large'
+      @bag.count = 3500
+      expect(@bag.size).to eq('large')
     end
 
     it 'should return the proper size for hefty range' do
-      @bag.count = 1501
-      @bag.size.should == 'hefty'
+      @bag.count = 4500
+      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'
+      @bag.count = rand(999) + 4000
+      expect(@bag.size).to eq('hefty')
     end
 
     it 'should return the proper size for hefty range' do
-      @bag.count = 2000
-      @bag.size.should == 'hefty'
+      @bag.count = 4500
+      expect(@bag.size).to eq('hefty')
     end
 
     it 'should return the proper size for huge range' do
-      @bag.count = 2001
-      @bag.size.should == 'huge'
+      @bag.count = 5000
+      expect(@bag.size).to eq('massive')
     end
 
     it 'should return the proper size for huge range' do
-      @bag.count = 20001
-      @bag.size.should == 'huge'
+      @bag.count = 20000
+      expect(@bag.size).to eq('massive')
     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-dicebag'
 require 'cinch/test'

metadata

@@ -1,141 +1,139 @@
 --- !ruby/object:Gem::Specification
 name: cinch-dicebag
 version: !ruby/object:Gem::Version
-  version: 1.0.10
+  version: 1.0.15
 platform: ruby
 authors:
 - Brian Haberer
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2014-07-22 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
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: 12.3.3
 - !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
+  name: codeclimate-test-reporter
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.4'
 - !ruby/object:Gem::Dependency
   name: cinch-test
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
       - !ruby/object:Gem::Version
-        version: '0'
+        version: '0.1'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.1
   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:
-    - - ! '>='
+        version: '0.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 2.0.12
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ! '>='
-      - !ruby/object:Gem::Version
-        version: 2.0.12
+        version: 0.1.1
 - !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
+        version: 1.1.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ! '>='
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+    - - ">="
       - !ruby/object:Gem::Version
-        version: 1.1.1
+        version: 1.1.5
 - !ruby/object:Gem::Dependency
   name: cinch-storage
   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'
 - !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:
@@ -144,8 +142,8 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- .gitignore
-- .travis.yml
+- ".gitignore"
+- ".travis.yml"
 - Gemfile
 - LICENSE.txt
 - README.md
@@ -162,26 +160,25 @@ homepage: https://github.com/bhaberer/cinch-dicebag
 licenses:
 - MIT
 metadata: {}
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ! '>='
+  - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.2.2
-signing_key: 
+rubygems_version: 3.2.6
+signing_key:
 specification_version: 4
-summary: ! 'Cinch Plugin: Dicebag and Dice rolls'
+summary: 'Cinch Plugin: Dicebag and Dice rolls'
 test_files:
 - spec/cinch-dicebag_spec.rb
 - spec/spec_helper.rb