rpg_tools 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0316fd1f6aea96942849150e125d95ea05a96411
+  data.tar.gz: 47f8012ecda7a42111f22a6bac44d65b5bb9016c
+SHA512:
+  metadata.gz: 556a6f049b6cbc5139c7ce4e56afd80efe981041534bfca5fb6a0fbfcdec5fb14efed10a477d3900c8b322f2121c2c2042cfa35e9817ff413fe12a48581ae0dc
+  data.tar.gz: 47dcde8a0c5227093b35e8c421e3a2958eff4beee3c94e21a94be3dd8ff1500a808e2c313dfcec4834d85cce1b8b6a8fe6367a6e56f2047eb70a46093ab67d14

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Yohan Piron
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,58 @@
+rpg_tools [![Dependency Status](https://gemnasium.com/Yinfei/rpg_tools.svg)](https://gemnasium.com/Yinfei/rpg_tools) ![](https://circleci.com/gh/Yinfei/rpg_tools.svg?&style=shield&circle-token=f5153100f0a56438602b915cf95d80f1e6e0edca)
+=======
+
+A gem that gives you tools for your RPGs : dices, coins and playing cards !
+
+## Usage
+
+### Coins
+
+`RpgTools::Coin.new`
+
+* The `flip` method set its value to a `heads` or `tails` string.
+
+### Dices
+
+`RpgTools.roll_dice(arg)` <i>(`arg` is case insensitive)</i>.
+
+This returns a plain integer result based on the `arg` parameter.
+
+* It can be a stardard dice like `"1dX"` for a X sided dice.
+
+* It can be a fudge dice `"df"` : a three sided dice (-1, 0, +1).
+
+* It can also be a percentile dice `"d%"` : a ten sided dice (from 10 to 100).
+
+You can also add multiple chained modifiers like "+X", "-X", "*X" or "/X", to alter the roll result. `RpgTools.roll_dice("4d6+2")` will create 4 6-sided dices, roll them and add 2 to the sum of the roll result.
+
+You can also manipulate all those dice types as objects :
+
+* `RpgTools::Dice::Numerical`
+* `RpgTools::Dice::Fudge`
+* `RpgTools::Dice::Percentile`
+
+All those classes take two args: a mandatory side number and an optional modifier.
+They respond to the `.roll` or `.roll!` methods to update their `value` to the result of the roll.
+
+`RpgTools::Dice::Numerical.new(6, '+4').roll` will roll a six sided dice and add 4 to the roll result.
+
+### Dice Bags
+
+`RpgTools::Dice::Bag.new(arg)` <i>(`arg` is case insensitive)</i>.
+
+* It works the same way `RpgTools.roll_dice` does but will give you a `RpgTools::Dice::Bag` object instead of a plain integer. `RpgTools::Dice::Bag.new("4d6-2")` will create a bag of four 6 sided dices with a -2 modifier to the sum of all rolls.
+
+### Playing card deck
+`RpgTools::PlayingCardDeck.new(arg)` <i>(`arg` can only be 32 or 52)</i>.
+
+* The `card` method returns a card of a 32 or 52 cards deck + 2 jokers, depending
+of `arg` value.
+* The `hand` method return an array of 5 `card` calls.
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Added some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,3 @@
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new('spec')

data/lib/rpg_tools/coin.rb

@@ -0,0 +1,32 @@
+module RpgTools
+  class Coin
+    attr_accessor :value, :flips, :heads, :tails
+
+    def initialize
+      @value, @flips, @heads, @tails = nil, 0, 0, 0
+    end
+
+    def flip
+      @flips += 1
+      @value = rand(2) == 1 ? 'Heads' : 'Tails'
+      save_result
+      @value
+    end
+    alias_method :flip!, :flip
+
+    private
+
+    def save_result
+      @heads += 1 if heads?
+      @tails += 1 if tails?
+    end
+
+    def heads?
+      @value == 'Heads'
+    end
+
+    def tails?
+      @value == 'Tails'
+    end
+  end
+end

data/lib/rpg_tools/dice/bag.rb

@@ -0,0 +1,65 @@
+module RpgTools
+  module Dice
+    class Bag
+      NOTATIONS ||= {
+        'D'  => Numerical,
+        'D%' => Percentile,
+        'DF' => Fudge
+      }.freeze
+
+      attr_accessor :dice_hash, :content, :modifiers, :value
+
+      def initialize(base)
+        @dice_hash = Utils::Parser.new(base).handle
+        @content = []
+        @modifiers = dice_hash[:modifiers]
+        @value = 0
+      end
+
+      def roll
+        invalid_dice! if dice_klass.nil?
+
+        fill_bag!
+
+        roll_bag_content!
+
+        return @total if modifiers.empty?
+
+        @total = Utils::ModifierCalculator.new(@total, modifiers).recalculate
+      end
+      alias roll! roll
+
+      private
+
+      def fill_bag!
+        quantity.times { @content << dice_klass.new(sides) }
+      end
+
+      def roll_bag_content!
+        @content.map(&:roll)
+
+        @total = @content.map(&:value).inject(0, :+)
+      end
+
+      def dice_klass
+        NOTATIONS[type]
+      end
+
+      def type
+        dice_hash[:type]
+      end
+
+      def sides
+        dice_hash[:sides]
+      end
+
+      def quantity
+        dice_hash[:quantity]
+      end
+
+      def invalid_dice!
+        raise ArgumentError, 'Unsupported dice type.'
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/base.rb

@@ -0,0 +1,52 @@
+module RpgTools
+  module Dice
+    class Base
+      attr_accessor :sides, :modifiers, :value, :rolls
+
+      def initialize(sides = 0, modifiers = '')
+        @sides = sides.zero? ? sides_count : sides
+        @modifiers = modifiers
+        @value = 0
+        @rolls = 0
+
+        check_sides
+      end
+
+      def roll
+        @rolls += 1
+
+        @value = perform_roll
+      end
+
+      private
+
+      def perform_roll
+        return roll_calculation if @modifiers.empty?
+
+        roll_with_modifiers
+      end
+
+      def roll_with_modifiers
+        Utils::ModifierCalculator.new(roll_calculation, @modifiers).recalculate
+      end
+
+      def roll_calculation
+        raise NotImplementedError
+      end
+
+      def sides_count
+        0
+      end
+
+      def check_sides
+        if not_enough_sides
+          raise ArgumentError, 'Your dice must have at least three sides.'
+        end
+      end
+
+      def not_enough_sides
+        @sides < 3
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/fudge.rb

@@ -0,0 +1,15 @@
+module RpgTools
+  module Dice
+    class Fudge < Base
+      def roll_calculation
+        rand(-1..1)
+      end
+
+      private
+
+      def sides_count
+        3
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/numerical.rb

@@ -0,0 +1,9 @@
+module RpgTools
+  module Dice
+    class Numerical < Base
+      def roll_calculation
+        rand(1..sides)
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/percentile.rb

@@ -0,0 +1,15 @@
+module RpgTools
+  module Dice
+    class Percentile < Base
+      def roll_calculation
+        (rand(1..10) * 10)
+      end
+
+      private
+
+      def sides_count
+        10
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/utils/modifier_calculator.rb

@@ -0,0 +1,53 @@
+module RpgTools
+  module Dice
+    module Utils
+      class ModifierCalculator
+        attr_accessor :total, :modifiers
+
+        def initialize(total, modifiers)
+          @total = total
+          @modifiers = modifiers
+
+          unprocessable_modifiers if malformed_modifiers?
+        end
+
+        def recalculate
+          modifier_operations.each do |operator, value|
+            @total = @total.send(operator, value.to_i)
+          end
+
+          @total
+        end
+
+        private
+
+        def modifier_operations
+          @modifiers.scan(/(\D)(\d+)/)
+        end
+
+        def unprocessable_modifiers
+          raise ArgumentError,
+                'Modifiers require both an operator and a numerical value.'
+        end
+
+        def malformed_modifiers?
+          no_operator_at_modifier_beginning? ||
+            no_number_at_modifier_end? ||
+            multiple_successive_operators?
+        end
+
+        def no_operator_at_modifier_beginning?
+          @modifiers.match(/^\D/).nil?
+        end
+
+        def no_number_at_modifier_end?
+          @modifiers.match(/\d+$/).nil?
+        end
+
+        def multiple_successive_operators?
+          !@modifiers.match(/\d?([^0-9]{2,})\d?$/).nil?
+        end
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice/utils/parser.rb

@@ -0,0 +1,46 @@
+module RpgTools
+  module Dice
+    module Utils
+      class Parser
+        attr_reader :dice
+
+        def initialize(dice)
+          @dice = dice.upcase.match(/^(\d+)([A-Z%]+)(\d*)(.*)$/)
+
+          quantity_error! if @dice.nil?
+        end
+
+        def handle
+          {
+            quantity: quantity,
+            type: type,
+            sides: sides,
+            modifiers: modifiers
+          }
+        end
+
+        private
+
+        def quantity
+          @dice[1].to_i
+        end
+
+        def type
+          @dice[2]
+        end
+
+        def sides
+          @dice[3].to_i
+        end
+
+        def modifiers
+          @dice[4]
+        end
+
+        def quantity_error!
+          raise ArgumentError, 'You must specify a dice quantity.'
+        end
+      end
+    end
+  end
+end

data/lib/rpg_tools/dice.rb

@@ -0,0 +1,8 @@
+require 'rpg_tools/dice/utils/modifier_calculator'
+require 'rpg_tools/dice/utils/parser'
+
+require 'rpg_tools/dice/base'
+require 'rpg_tools/dice/fudge'
+require 'rpg_tools/dice/numerical'
+require 'rpg_tools/dice/percentile'
+require 'rpg_tools/dice/bag'

data/lib/rpg_tools/playing_card_deck.rb

@@ -0,0 +1,64 @@
+module RpgTools
+  class PlayingCardDeck
+    attr_accessor :type, :card_picks, :value
+
+    def initialize(type)
+      @type = type
+      type_check
+      @card_picks = 0
+      @value = nil
+    end
+
+    def card
+      @card_picks += 1
+
+      @value =
+        if @type == 52
+          joker_picked? ? 'Joker' : standard_card
+        else
+          standard_card
+        end
+    end
+
+    def hand
+      [].tap do |hand|
+        until hand.count == 5
+          card = standard_card
+
+          unless hand.include?(card) || hand.count('Joker') == 2
+            hand << card
+            @card_picks += 1
+          end
+        end
+      end
+    end
+
+    private
+
+    def type_check
+      unless [32, 52].include?(@type)
+        raise ArgumentError.new('A playing card deck contains 32 or 52 cards only.')
+      end
+    end
+
+    def joker_picked?
+      [0, 1].include?((0..54).to_a.sample(1).first)
+    end
+
+    def number
+      if @type == 32
+        [(7..10).to_a, 'Jack', 'Queen', 'King'].flatten.sample(1)
+      else
+        [(1..10).to_a, 'Jack', 'Queen', 'King'].flatten.sample(1)
+      end
+    end
+
+    def color
+      ['Clubs', 'Hearts', 'Diamonds', 'Spades'].sample(1)
+    end
+
+    def standard_card
+      @value = [number, color].join(' of ')
+    end
+  end
+end

data/lib/rpg_tools.rb

@@ -0,0 +1,10 @@
+require 'rpg_tools/coin'
+require 'rpg_tools/dice'
+require 'rpg_tools/playing_card_deck'
+
+module RpgTools
+  def roll_dice(dice)
+    Dice::Bag.new(dice).roll
+  end
+  module_function :roll_dice
+end

data/rpg_tools.gemspec

@@ -0,0 +1,16 @@
+Gem::Specification.new do |s|
+  s.name        = %q{rpg_tools}
+  s.version     = '1.0.0'
+  s.author      = 'Yohan Piron'
+  s.email       = 'yinfei84@gmail.com'
+  s.date        = '2015-08-03'
+  s.summary     = 'rpg_tools is a toolbox for tabletop games and RPGs'
+  s.description = 'rpg_tools gives you tools for your RPGs : dices, coins, cards...'
+  s.homepage    = 'https://github.com/Yinfei/rpg_tools.git'
+  s.license     = 'MIT'
+  s.files       = `git ls-files`.split("\n")
+  s.test_files    = s.files.grep(%r{^(spec)/})
+  s.require_paths = ['lib']
+  s.add_development_dependency 'rake', '~> 10.4'
+  s.add_development_dependency 'rspec', '~> 3.0'
+end

data/spec/coin_spec.rb

@@ -0,0 +1,8 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Coin do
+  it "can't return anything else than 'Heads' or 'Tails'" do
+    expect(['Heads', 'Tails'].include?(described_class.new.flip)).to eq(true)
+  end
+end

data/spec/dice/bag_spec.rb

@@ -0,0 +1,59 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Bag do
+  describe '#roll' do
+    it "doesn't roll a dice without quantity" do
+      expect { described_class.new('d10').roll }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't roll a 'd0' dice" do
+      expect { described_class.new('1d0').roll }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't roll a 'd1' dice" do
+      expect { described_class.new('1d1').roll }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't roll a 'd2' dice" do
+      expect { described_class.new('1d2').roll }.to raise_error(ArgumentError)
+    end
+
+    it 'rolls fudge dices' do
+      expect { described_class.new('1df').roll }.not_to raise_error
+    end
+
+    it "rolls a dice may the 'd' char be capitalized or not" do
+      expect { described_class.new('1d6').roll }.not_to raise_error
+      expect { described_class.new('1D6').roll }.not_to raise_error
+    end
+
+    it "rolls a dice may the 'f' char be capitalized or not" do
+      expect { described_class.new('1dF').roll }.not_to raise_error
+      expect { described_class.new('1Df').roll }.not_to raise_error
+    end
+
+    it 'rolls a dice with a bonus' do
+      expect { described_class.new('1d6+2').roll }.not_to raise_error
+    end
+
+    it 'rolls a dice with a malus' do
+      expect { described_class.new('1D6-2').roll }.not_to raise_error
+    end
+
+    it 'rolls a dice with a multiple modifiers' do
+      expect { described_class.new('1D6-2+4/8').roll }.not_to raise_error
+    end
+
+    it 'does not roll a dice with bad modifiers' do
+      expect { described_class.new('1D6-+2').roll }.to raise_error(ArgumentError)
+      expect { described_class.new('1D6-+2+').roll }.to raise_error(ArgumentError)
+    end
+
+    it "doesn't roll very odd dices" do
+      expect { described_class.new('1dDOGE').roll }.to raise_error(ArgumentError)
+      expect { described_class.new('1dfoo').roll }.to raise_error(ArgumentError)
+      expect { described_class.new('1foobarbaz').roll }.to raise_error(ArgumentError)
+    end
+  end
+end

data/spec/dice/base_spec.rb

@@ -0,0 +1,96 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Base do
+  let(:dice) { described_class.new(10) }
+  let(:dice_with_modifier) { described_class.new(10, '+2') }
+
+  describe '#initialize' do
+    it 'creates a basic dice' do
+      expect { described_class.new(10) }.not_to raise_error
+    end
+
+    it 'creates a basic dice with a modifier' do
+      expect { described_class.new(10, '+2') }.not_to raise_error
+    end
+
+    it 'falls back on sides_count method if no sides arg is provided' do
+      allow_any_instance_of(described_class).to receive(:sides_count).and_return(7)
+
+      new_dice = described_class.new
+
+      expect(new_dice.sides).to eq(7)
+    end
+  end
+
+  describe '#roll' do
+    before do
+      allow(dice).to receive(:roll_calculation).and_return(10)
+      allow(dice_with_modifier).to receive(:roll_calculation).and_return(10)
+    end
+
+    context 'no modifier' do
+      it 'returns an integer based on a basic roll calculation' do
+        expect(dice.roll).to eq(10)
+      end
+
+      it 'does not call the #roll_with_modifiers method' do
+        expect(dice).not_to receive(:roll_with_modifiers)
+
+        dice.roll
+      end
+    end
+
+    context 'modifier present' do
+      it 'returns an integer based on a roll calulation plus modifier applied' do
+        expect(dice_with_modifier.roll).to eq(12)
+      end
+
+      it 'calls the #roll_with_modifiers method' do
+        expect(dice_with_modifier).to receive(:roll_with_modifiers)
+
+        dice_with_modifier.roll
+      end
+    end
+
+    it 'updates a dice value attribute' do
+      dice.roll
+
+      expect(dice.value).to eq(10)
+    end
+
+    it 'increments to dice roll count' do
+      dice.roll
+
+      expect(dice.rolls).to eq(1)
+
+      dice.roll
+
+      expect(dice.rolls).to eq(2)
+    end
+  end
+
+  describe '#sides_count' do
+    it 'returns zero' do
+      expect(dice.send(:sides_count)).to eq(0)
+    end
+  end
+
+  describe '#roll_calculation' do
+    it 'raises a NotImplementedError' do
+      expect { dice.send(:roll_calculation) }.to raise_error(NotImplementedError)
+    end
+  end
+
+  describe 'not_enough_sides' do
+    it 'returns true if dice sides is less than three' do
+      dice.sides = 2
+
+      expect(dice.send(:not_enough_sides)).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      expect(dice.send(:not_enough_sides)).to be(false)
+    end
+  end
+end

data/spec/dice/fudge_spec.rb

@@ -0,0 +1,22 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Fudge do
+  let(:dice) { described_class.new }
+
+  describe '#roll_calculation' do
+    it 'rolls a value between -1 and 1' do
+      10.times do
+        dice.roll
+
+        expect(dice.value.between?(-1, 1)).to be(true)
+      end
+    end
+  end
+
+  describe '#sides_count' do
+    it 'returns 3' do
+      expect(dice.send(:sides_count)).to eq(3)
+    end
+  end
+end

data/spec/dice/numerical_spec.rb

@@ -0,0 +1,16 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Numerical do
+  let(:dice) { described_class.new(10) }
+
+  describe '#roll_calculation' do
+    it 'rolls a value between 1 and the sides value' do
+      10.times do
+        dice.roll
+
+        expect(dice.value.between?(1, dice.sides)).to be(true)
+      end
+    end
+  end
+end

data/spec/dice/percentile_spec.rb

@@ -0,0 +1,30 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Percentile do
+  let(:dice) { described_class.new }
+
+  describe '#roll_calculation' do
+    it 'rolls a value between 10 and 100' do
+      10.times do
+        dice.roll
+
+        expect(dice.value.between?(10, 100)).to be(true)
+      end
+    end
+
+    it 'rolls only round values' do
+      10.times do
+        dice.roll
+
+        expect(dice.value[-1]).to eq(0)
+      end
+    end
+  end
+
+  describe '#sides_count' do
+    it 'returns 10' do
+      expect(dice.send(:sides_count)).to eq(10)
+    end
+  end
+end

data/spec/dice/utils/modifier_calculator_spec.rb

@@ -0,0 +1,96 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Utils::ModifierCalculator do
+  let(:dice) { described_class.new(10, '+1') }
+
+  describe '#initialize' do
+    it 'raises an error for malformed modifiers' do
+      expect { described_class.new(10, '+3+') }.to raise_error(ArgumentError)
+    end
+
+    it 'does not otherwise' do
+      expect { described_class.new(10, '+5-3/10') }.not_to raise_error
+    end
+  end
+
+  describe '#recalculate' do
+    it 'applies a simple modifier to the total attribute' do
+      dice = described_class.new(10, '+5')
+
+      dice.recalculate
+
+      expect(dice.total).to eq(15)
+    end
+
+    it 'applies multiple modifiers to the total attribute' do
+      dice = described_class.new(10, '+5-1/2')
+
+      dice.recalculate
+
+      expect(dice.total).to eq(7)
+    end
+  end
+
+  describe '#malformed_modifiers?' do
+    it 'returns true if there is not operator at modifiers beginning' do
+      dice.modifiers = '4'
+
+      expect(dice.send(:malformed_modifiers?)).to be(true)
+    end
+
+    it 'returns true if there is no number at modifiers end' do
+      dice.modifiers = '+3-'
+
+      expect(dice.send(:malformed_modifiers?)).to be(true)
+    end
+
+    it 'returns true if multiple succesive operators are present in the modifiers' do
+      dice.modifiers = '+-3'
+
+      expect(dice.send(:malformed_modifiers?)).to be(true)
+    end
+
+    it 'returns false otherwise' do
+      dice.modifiers = '+4-5/8'
+
+      expect(dice.send(:malformed_modifiers?)).to be(false)
+    end
+  end
+
+  describe '#no_operator_at_modifier_beginning?' do
+    it 'returns true if there is not operator at modifiers beginning' do
+      dice.modifiers = '4'
+
+      expect(dice.send(:no_operator_at_modifier_beginning?)).to be(true)
+    end
+
+    it 'returs false otherwise' do
+      expect(dice.send(:no_operator_at_modifier_beginning?)).to be(false)
+    end
+  end
+
+  describe '#no_number_at_modifier_end?' do
+    it 'returns true if there is no number at modifiers end' do
+      dice.modifiers = '+3-'
+
+      expect(dice.send(:no_number_at_modifier_end?)).to be(true)
+    end
+
+    it 'returs false otherwise' do
+      expect(dice.send(:no_number_at_modifier_end?)).to be(false)
+    end
+  end
+
+  describe '#multiple_successive_operators?' do
+    it 'returns true if multiple succesive operators are present in the modifiers' do
+    dice.modifiers = '+-3'
+
+      expect(dice.send(:multiple_successive_operators?)).to be(true)
+    end
+
+    it 'returs false otherwise' do
+      expect(dice.send(:multiple_successive_operators?)).to be(false)
+    end
+  end
+end

data/spec/dice/utils/parser_spec.rb

@@ -0,0 +1,28 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::Dice::Utils::Parser do
+  describe '#initialize' do
+    it 'raises an error when no matching pattern is found' do
+      expect { described_class.new('DOGE') }.to raise_error(ArgumentError)
+    end
+
+    it 'does not otherwise' do
+      expect { described_class.new('1DF') }.not_to raise_error
+      expect { described_class.new('1D10') }.not_to raise_error
+      expect { described_class.new('1D10+12') }.not_to raise_error
+      expect { described_class.new('1D%') }.not_to raise_error
+    end
+  end
+
+  describe '#handle' do
+    it 'builds a hash based on a matching pattern' do
+      hash = described_class.new('3DF+4').handle
+
+      expect(hash[:quantity]).to eq(3)
+      expect(hash[:type]).to eq('DF')
+      expect(hash[:sides]).to eq(0)
+      expect(hash[:modifiers]).to eq('+4')
+    end
+  end
+end

data/spec/playing_card_deck_spec.rb

@@ -0,0 +1,28 @@
+require 'rpg_tools'
+require 'spec_helper'
+
+describe RpgTools::PlayingCardDeck do
+  it 'must return a card name' do
+    expect(described_class.new(32).card).not_to eq(true)
+    expect(described_class.new(32).card).not_to eq(false)
+    expect(described_class.new(32).card).not_to eq(nil)
+    expect(described_class.new(52).card).not_to eq(true)
+    expect(described_class.new(52).card).not_to eq(false)
+    expect(described_class.new(52).card).not_to eq(nil)
+  end
+
+  it 'must return 5 cards for a full hand' do
+    expect(described_class.new(32).hand.count).to eq(5)
+    expect(described_class.new(52).hand.count).to eq(5)
+  end
+
+  it "can't pick the same card twice" do
+    expect(described_class.new(32).hand.uniq.count).to eq(5)
+    expect(described_class.new(52).hand.uniq.count).to eq(5)
+  end
+
+  it "can't use anything else than a 32 or 52 cards deck" do
+    expect { described_class.new(42) }.to raise_error(ArgumentError)
+    expect { described_class.new(666) }.to raise_error(ArgumentError)
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,13 @@
+RSpec.configure do |config|
+  config.color     = true
+  config.tty       = true
+  config.formatter = :documentation
+
+  config.mock_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+
+  config.expect_with :rspec do |c|
+    c.syntax = [:should, :expect]
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification
+name: rpg_tools
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Yohan Piron
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: 'rpg_tools gives you tools for your RPGs : dices, coins, cards...'
+email: yinfei84@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/rpg_tools.rb
+- lib/rpg_tools/coin.rb
+- lib/rpg_tools/dice.rb
+- lib/rpg_tools/dice/bag.rb
+- lib/rpg_tools/dice/base.rb
+- lib/rpg_tools/dice/fudge.rb
+- lib/rpg_tools/dice/numerical.rb
+- lib/rpg_tools/dice/percentile.rb
+- lib/rpg_tools/dice/utils/modifier_calculator.rb
+- lib/rpg_tools/dice/utils/parser.rb
+- lib/rpg_tools/playing_card_deck.rb
+- rpg_tools.gemspec
+- spec/coin_spec.rb
+- spec/dice/bag_spec.rb
+- spec/dice/base_spec.rb
+- spec/dice/fudge_spec.rb
+- spec/dice/numerical_spec.rb
+- spec/dice/percentile_spec.rb
+- spec/dice/utils/modifier_calculator_spec.rb
+- spec/dice/utils/parser_spec.rb
+- spec/playing_card_deck_spec.rb
+- spec/spec_helper.rb
+homepage: https://github.com/Yinfei/rpg_tools.git
+licenses:
+- MIT
+metadata: {}
+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.6.8
+signing_key: 
+specification_version: 4
+summary: rpg_tools is a toolbox for tabletop games and RPGs
+test_files:
+- spec/coin_spec.rb
+- spec/dice/bag_spec.rb
+- spec/dice/base_spec.rb
+- spec/dice/fudge_spec.rb
+- spec/dice/numerical_spec.rb
+- spec/dice/percentile_spec.rb
+- spec/dice/utils/modifier_calculator_spec.rb
+- spec/dice/utils/parser_spec.rb
+- spec/playing_card_deck_spec.rb
+- spec/spec_helper.rb