cinch-dicebag 1.0.9 → 1.0.10

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 !binary "U0hBMQ==":
-  metadata.gz: ab59f8709ed5aee1d8354910616d518933583bda
-  data.tar.gz: 353ef745e42b012d36c2e4efad611ef885eabcba
+  metadata.gz: 03ffcf66f79f8ac4138c0616c87bdec979c8a68b
+  data.tar.gz: 2ffd9ee34d9838564ce75c3823645f4d6b8d6016
 SHA512:
-  metadata.gz: 20e7c611ae9235b4dab39e4d78717a39e169ecbbceecf2effacbb7870ea93b89cbbee0f744ff78e019300d9f285478290aaa167469e06b5d79670288b6dc2357
-  data.tar.gz: f38172852b8b6d52c37895a60167318f9010c2b8fe9655d558a701ef1aec62b8b024fc24da9e2beb8df3cc0f5ae7fe98aff1bdba2fe88fd51da8b969c7d848c9
+  metadata.gz: 28deec95c393d146cf89c89aa49f476838f5e23aa045217addfdb3fccd7fb8a553be9c669b3a160e6956c29da0e611190370a4d60ffc726b30a781febf5ba1d0
+  data.tar.gz: 63c0c078021222b79ebed0dd726c191d5e57eb3ee87799f6f94c767d41f106c4c3d65dd87cd415742e9ba218226df1c865ca1e744f5dfc164692f90c92cc9af6

data/.travis.yml

@@ -10,7 +10,6 @@ rvm:
   - 1.8.7
   - jruby-18mode
   - jruby-19mode
-  - rbx
   - ruby-head
   - jruby-head
   - ree

data/lib/cinch-dicebag.rb

@@ -1,3 +1,5 @@
 # -*- encoding : utf-8 -*-
 require 'cinch/plugins/dicebag/version'
 require 'cinch/plugins/dicebag'
+require 'cinch/plugins/dicebag/die'
+require 'cinch/plugins/dicebag/bag'

data/lib/cinch/plugins/dicebag.rb

@@ -18,13 +18,15 @@ module Cinch::Plugins
                 'use .roll (dice count)d(sides) to roll specific dice ' +
                 '(e.g. .roll 4d6 3d20)'
 
-    match /dicebag/,        method: :roll_dicebag
+    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.
@@ -32,19 +34,22 @@ module Cinch::Plugins
     # @param [Cinch::Channel] channel The Channel object where the roll took
     #   place.
     # @return [String] A description of the roll that took place
-    def roll_dicebag(m)
-      if m.channel.nil?
-        m.reply 'You must use that command in the main channel'
-        return
-      end
-
-      dice  = { d4: rand(250), d6: rand(500), d10: rand(750), d20: rand(1000) }
-      total = roll_dice(dice.map { |die, count| "#{count}#{die}" })
-      size  = get_bag_size(dice.values.inject(:+))
-
-      m.reply "#{m.user.nick} rolls a #{size} bag of dice totalling " +
-              "#{total}. " +
-              score_check(m.user.nick.downcase, m.channel.name, total)
+    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
@@ -53,82 +58,18 @@ module Cinch::Plugins
     #   (i.e. '6d12 4d20 d10'
     # @return [String] String describing the dice that were rolled
     def roll(m, dice = '1d20')
-      result = roll_dice(dice.split(' '))
-
+      result = Die.roll(dice.split(' '))
       result = "#{m.user.nick} rolls #{dice} totalling #{result}" if result.is_a?(Integer)
-      m.reply result
-    end
-
-    # Takes an Array of dice rolls, sanitizes them, parses them, and dispatches
-    #   their calculation to `roll_die`.
-    # @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 roll_dice(dice)
-      # Clean out anything invalid
-      dice.delete_if { |d| d.match(/\d*d\d+([\-\+]\d+)?/).nil? }
-
-      return roll_check?(dice) if roll_check?(dice)
-      
-      # Roll each group and total up the returned value
-      total = nil
-      dice.each do |die|
-        total ||= 0
-        total += roll_die(die)
-      end
-
-      total
-    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 [Fixnum] The total from rolling all of the dice.
-    def roll_check?(dice)
-      # Check to make sure it's not a stupid large roll, they clog threads.
-      count = dice.map { |die| die[/(\d+)d\d+/, 1].to_i || 1 }.inject(0, :+)
-      return 'I don\'t have that many dice in my bag!' unless count <= 10_000
-      false
-    end
-
-    # Rolls an n-sided die a given amount of times and returns the total
-    # @param [Fixn] count Number of times to roll the die.
-    # @return [Fixnum] The total from rolling the die.
-    def roll_die(die)
-      modifier = die[/[\-\+]\d+/]
-
-      count = (die[/(\d+)d\d+/, 1] || 1).to_i
-      sides = die[/\d?d(\d+)/, 1].to_i
-
-      return 0 if count.nil? || sides.nil? || sides < 1 || count < 1
-
-      total = 0
-      count.times { total += rand(sides) + 1 }
-
-      return total += parse_modifier(modifier) unless modifier.nil?
-
-      total
+      m.reply result
     end
 
-    def parse_modifier(modifier)
-      operator = modifier[/\A[\+\-]/]
-      int = modifier[/\d+\z/].to_i
-      0.send(operator, int)
-    end
+    private
 
-    # 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 get_bag_size(size)
-      case size
-      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
+    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

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

@@ -0,0 +1,48 @@
+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
+
+      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
+
+      # 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
+
+      private
+
+      def die_array
+        @dice.keys.map do |sides|
+          "#{sides}d#{@dice[sides]}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,78 @@
+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)
+        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)
+        modifier = die[MOD_REGEX]
+
+        count = (die[ROLLS_REGEX, 1] || 1).to_i
+        sides = die[SIDES_REGEX, 1].to_i
+
+        return 0 if count.nil? || sides.nil? || sides < 1 || count < 1
+
+        total = 0
+        count.times { total += rand(sides) + 1 }
+
+        return total += parse_modifier(modifier) unless modifier.nil?
+
+        total
+      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
+
+      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.9'
+    VERSION = '1.0.10'
   end
 end

data/spec/cinch-dicebag_spec.rb

@@ -77,101 +77,185 @@ describe Cinch::Plugins::Dicebag do
 
     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 be_eql("You must use that command in the main channel")
+        should == '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+/)
     end
+  end
+
+  describe 'scores' do
+    before(:each) do
+      @bot.plugins.first.storage.data['#foo'] = { 'brian' => { score: 1, time: Time.now },
+                                                  'braad' => { score: 2, time: Time.now },
+                                                  'billy' => { score: 3, time: Time.now },
+                                                  'britt' => { score: 4, time: Time.now },
+                                                  'brett' => { score: 5, time: Time.now },
+                                                  'paulv' => { score: 6, time: Time.now },
+                                                  'stacy' => { score: 7, time: Time.now },
+                                                  'calrs' => { score: 8, time: Time.now },
+                                                  'susie' => { score: 9, time: Time.now },
+                                                  'enton' => { score: 10, time: Time.now },
+                                                  'grill' => { score: 11, time: Time.now },
+                                                  'evilg' => { score: 12, time: Time.now },
+                                                  'mobiu' => { score: 13, time: Time.now },
+                                                  'gamma' => { score: 14, time: Time.now },
+                                                  'omega' => { score: 15, time: Time.now } }
+    end
 
     it 'should announce a high score if the old score is higher' do
-      get_replies(make_message(@bot, '!dicebag' , { nick: 'brian', channel: '#foo' }))
-      @bot.plugins.first.storage.data['#foo']['brian'] = { score: 1, time: Time.now }
       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+/)
     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]'
+    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
+    end
   end
 
   describe 'roll_dice' do
     it 'should return nil if the dice list is empty' do
-      @bot.plugins.first.roll_dice([]).should be_nil
+      Cinch::Plugins::Dicebag::Die.roll([]).should be_nil
     end
 
     it 'should return a non zero total on a normal dice list' do
-      @bot.plugins.first.roll_dice(['3d3', '4d5']).should_not be_zero
+      Cinch::Plugins::Dicebag::Die.roll(['3d3', '4d5']).should_not be_zero
     end
 
     it 'should clear out any invalid dice rolls' do
-      @bot.plugins.first.roll_dice(['33']).should be_nil
+      Cinch::Plugins::Dicebag::Die.roll(['33']).should be_nil
     end
 
     it 'should allow modifiers' do
-      @bot.plugins.first.roll_dice(['1d1+1', '1d1-4']).should == -1
+      Cinch::Plugins::Dicebag::Die.roll(['1d1+1', '1d1-4']).should == -1
     end
   end
 
-  describe 'roll_die' do
+  describe 'Die.roll' do
     it 'should return an acceptable value for a given roll' do
-      @bot.plugins.first.roll_die('1d1').should == 1
-      (3..15).should include(@bot.plugins.first.roll_die('3d5'))
+      Cinch::Plugins::Dicebag::Die.roll('1d1').should == 1
+      (3..15).should include(Cinch::Plugins::Dicebag::Die.roll('3d5'))
     end
 
-    it 'should return 0 for any negetive values' do
-      @bot.plugins.first.roll_die('1d-1').should == 0
-      @bot.plugins.first.roll_die('-1d-1').should == 0
+    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
     end
 
     it 'should add modifiers to the total' do
-      @bot.plugins.first.roll_die('1d1+2').should == 3
-      @bot.plugins.first.roll_die('3d1-2').should == 1
+      Cinch::Plugins::Dicebag::Die.roll('1d1+2').should == 3
+      Cinch::Plugins::Dicebag::Die.roll('3d1-2').should == 1
     end
 
     it 'should allow modifiers to take the total below zero' do
-      @bot.plugins.first.roll_die('1d1-1').should == 0
-      @bot.plugins.first.roll_die('1d1-2').should == -1
+      Cinch::Plugins::Dicebag::Die.roll('1d1-1').should == 0
+      Cinch::Plugins::Dicebag::Die.roll('1d1-2').should == -1
     end
   end
 
   describe 'get_bag_size' do
+    before(:each) do
+      @bag = Cinch::Plugins::Dicebag::Bag.new({})
+    end
+
     it 'should return \'huge\' for out of bounds queries' do
-      @bot.plugins.first.get_bag_size(50000).should == 'huge'
+      @bag.count = 50000
+      @bag.size.should == 'huge'
     end
 
     it 'should return the proper size for tiny range' do
-      @bot.plugins.first.get_bag_size(0).should            == 'tiny'
-      @bot.plugins.first.get_bag_size(rand(100)).should    == 'tiny'
-      @bot.plugins.first.get_bag_size(100).should          == 'tiny'
+      @bag.count = 0
+      @bag.size.should == 'tiny'
+    end
+
+    it 'should return the proper size for small range' do
+      @bag.count = rand(100)
+      @bag.size.should == 'tiny'
+    end
+
+    it 'should return the proper size for small range' do
+      @bag.count = 100
+      @bag.size.should == 'tiny'
+    end
+
+    it 'should return the proper size for small range' do
+      @bag.count = 101
+      @bag.size.should == 'small'
+    end
+
+    it 'should return the proper size for small range' do
+      @bag.count = rand(399) + 101
+      @bag.size.should == 'small'
     end
 
     it 'should return the proper size for small range' do
-      @bot.plugins.first.get_bag_size(101).should              == 'small'
-      @bot.plugins.first.get_bag_size(rand(399) + 101).should  == 'small'
-      @bot.plugins.first.get_bag_size(500).should              == 'small'
+      @bag.count = 500
+      @bag.size.should == 'small'
     end
 
     it 'should return the proper size for medium range' do
-      @bot.plugins.first.get_bag_size(501).should              == 'medium'
-      @bot.plugins.first.get_bag_size(rand(499) + 501).should  == 'medium'
-      @bot.plugins.first.get_bag_size(1000).should             == 'medium'
+      @bag.count = 501
+      @bag.size.should == 'medium'
+    end
+
+    it 'should return the proper size for medium range' do
+      @bag.count = rand(499) + 501
+      @bag.size.should == 'medium'
+    end
+
+    it 'should return the proper size for medium range' do
+      @bag.count = 1000
+      @bag.size.should == 'medium'
     end
 
     it 'should return the proper size for large range' do
-      @bot.plugins.first.get_bag_size(1001).should              == 'large'
-      @bot.plugins.first.get_bag_size(rand(499) + 1001).should  == 'large'
-      @bot.plugins.first.get_bag_size(1500).should              == 'large'
+      @bag.count = 1001
+      @bag.size.should == 'large'
+    end
+
+    it 'should return the proper size for large range' do
+      @bag.count = rand(499) + 1001
+      @bag.size.should == 'large'
+    end
+
+    it 'should return the proper size for large range' do
+      @bag.count = 1500
+      @bag.size.should == 'large'
+    end
+
+    it 'should return the proper size for hefty range' do
+      @bag.count = 1501
+      @bag.size.should == 'hefty'
+    end
+
+    it 'should return the proper size for hefty range' do
+      @bag.count = rand(499) + 1501
+      @bag.size.should == 'hefty'
     end
 
     it 'should return the proper size for hefty range' do
-      @bot.plugins.first.get_bag_size(1501).should              == 'hefty'
-      @bot.plugins.first.get_bag_size(rand(499) + 1501).should  == 'hefty'
-      @bot.plugins.first.get_bag_size(2000).should              == 'hefty'
+      @bag.count = 2000
+      @bag.size.should == 'hefty'
+    end
+
+    it 'should return the proper size for huge range' do
+      @bag.count = 2001
+      @bag.size.should == 'huge'
     end
 
     it 'should return the proper size for huge range' do
-      @bot.plugins.first.get_bag_size(2001).should              == 'huge'
-      @bot.plugins.first.get_bag_size(20001).should             == 'huge'
+      @bag.count = 20001
+      @bag.size.should == 'huge'
     end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: cinch-dicebag
 version: !ruby/object:Gem::Version
-  version: 1.0.9
+  version: 1.0.10
 platform: ruby
 authors:
 - Brian Haberer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-01 00:00:00.000000000 Z
+date: 2014-07-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -153,6 +153,8 @@ files:
 - cinch-dicebag.gemspec
 - lib/cinch-dicebag.rb
 - lib/cinch/plugins/dicebag.rb
+- lib/cinch/plugins/dicebag/bag.rb
+- lib/cinch/plugins/dicebag/die.rb
 - lib/cinch/plugins/dicebag/version.rb
 - spec/cinch-dicebag_spec.rb
 - spec/spec_helper.rb