tabletop 0.0.1

data/.gitignore

@@ -0,0 +1,3 @@
+Gemfile.lock
+.DS_Store
+pkg/

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Nick Novitski
+
+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.markdown

@@ -0,0 +1,44 @@
+# tabletop
+
+Tabletop aims to provide a simple way of describing, automating and tracking the tools and tasks involved in "analog" games, determining results from the motions and properties of various dice and chips.
+
+Currently, you can roll dice with it.
+
+## Installation
+
+    gem install tabletop
+
+## Usage
+
+Just `require 'tabletop'` and off you go!  The easiest way to create a pool of dice is exactly the way you'd expect.
+
+    3.d6           #=> [3 (d6), 3 (d6), 4 (d6)]
+    2.d10 + 1.d8   #=> [2 (d10), 6 (d10), 8 (d8)]
+    6.d17          #=> [8 (d17), 3 (d17), 7 (d17), 16 (d17), 11 (d17), 10 (d17)]
+    
+Pools are arrays of Dice objects that have a few nice extra functions.
+
+    d&d_strength = 3.d6.roll.sum #=> 13
+    ore_character = 10.d10.sets #=> ["3x2", "2x8", "1x7", "1x6", "1x4", "1x3", "1x1"]
+    cortex_result = (1.d8 + 2.d6 + 1.d4).highest(2).sum  #=> 9
+    
+Dice are pretty straightforward.
+
+    d = Die.new
+    d.sides     #=> 6
+    d.result    #=> 4
+    d.roll      #=> "2 (d6)"
+
+## Note on Patches/Pull Requests
+ 
+* Fork the project.
+* Create a topic branch
+* Make tests that describe your feature addition or bug fix.
+* Write code that passes those tests
+* Commit, without altering the rakefile or version.
+  (if you want to have your own version, that is fine but bump version in a commit by itself I can ignore when I pull)
+* Send me a pull request.
+
+## Copyright
+
+Copyright (c) 2011 Nick Novitski. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,37 @@
+require 'rubygems'
+
+begin
+  require 'bundler'
+rescue LoadError
+  $stderr.puts "You must install bundler - run `gem install bundler`"
+end
+
+begin
+  Bundler.setup
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'bueller'
+Bueller::Tasks.new
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:examples) do |examples|
+  examples.rspec_opts = '-Ispec'
+end
+
+task :default => :examples
+
+require 'rdoc/task'
+RDoc::Task.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.main = 'README.rdoc'
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "tabletop #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/lib/fixnum.rb

@@ -0,0 +1,28 @@
+require 'tabletop'
+
+class Fixnum
+  def dX(sides)
+    dice = []
+    times { dice << Tabletop::Die.new(sides) }
+    Tabletop::Pool.new(dice)
+  end
+  def dF
+    dice = []
+    times {dice << Tabletop::FudgeDie.new}
+    Tabletop::Pool.new(dice)
+  end
+  def method_missing(symbol, *args, &block)
+    if symbol =~ /^d(.*)$/
+      dX($1.to_i)
+    else
+      super
+    end
+  end
+  def respond_to?(symbol, include_private = false)
+    if symbol.to_s =~ /^d(.*)$/
+      true if $1.to_i > 0
+    else
+      super
+    end
+  end
+end

data/lib/tabletop/die.rb

@@ -0,0 +1,59 @@
+module Tabletop
+  class Die
+    include Comparable
+    attr_reader :sides, :result
+    def initialize(sides=6, result=nil)
+      if sides <= 0
+        raise ArgumentError, "Die cannot have #{sides} sides"
+      end
+      unless sides.kind_of? Integer
+        raise ArgumentError, "Parameter must be Integer, not #{sides.class}"
+      end
+      @sides = sides
+      if result.nil?
+        result = roll
+      else
+        raise ArgumentError unless valid_result?(result)
+      end
+      @result = result
+    end
+    def roll
+      @result = rand(sides)+1
+    end
+    def inspect
+      "#{@result} (d#{@sides})"
+    end
+    def result=(new_result)
+      raise ArgumentError unless valid_result?(new_result)  
+      @result = new_result
+    end
+    def <=>(operand)
+      @result <=> operand.to_int
+    end
+    def to_int
+      @result
+    end
+    
+    protected
+    def valid_result?(result)
+      result > 0 and result <= @sides
+    end
+  end
+  
+  class FudgeDie < Die
+    def initialize(result = nil)
+      super(3, result)
+    end
+    def roll
+      @result = rand(sides)-1
+    end
+    def inspect
+      "[#{['-', ' ', '+'][@result+1]}] (dF)"
+    end
+    
+    protected
+    def valid_result?(result)
+      [1,0,-1].include?(result)
+    end
+  end
+end

data/lib/tabletop/pool.rb

@@ -0,0 +1,115 @@
+require_relative 'die'
+require 'delegate'
+
+module Tabletop
+  class Pool < DelegateClass(Array)
+    include Comparable
+    def initialize(init_dice)
+      return super(init_dice) if init_dice.class == Array
+      d_groups = init_dice.split
+      dice = []
+      d_groups.each do |d_notation|
+        number, sides = d_notation.split('d')
+        number = number.to_i
+        number += 1 if number == 0
+        if sides.to_i > 0
+          number.times { dice << Die.new(sides.to_i)}
+        elsif sides == "F"
+          number.times {dice << FudgeDie.new}
+        end
+      end
+      super(dice)
+    end
+    def +(operand)
+      # if the operator is a pool, or an array only of Die objects...
+      if operand.class == Pool or (operand.class == Array and !(operand.detect{|obj| obj.class != Die}))
+        new_union(operand)
+      elsif operand.kind_of? Numeric
+        sum + operand
+      else
+        raise ArgumentError, "Cannot add operand of class #{operand.class}"
+      end
+    end
+    
+    def <=>(operand)
+        sum <=> operand.to_int
+    end
+      
+    def results
+      map {|die| die.result}
+    end
+    def dice
+      fudge = nil
+      result = {}
+      each do |die|
+        if die.class == FudgeDie
+          fudge = count {|d| d.class == FudgeDie}
+        else
+          result[die.sides] = count {|d| d.sides == die.sides}
+        end
+      end
+      d_array = result.sort.collect do |d_group| 
+        number = d_group[1]
+        number = "" if number == 1
+        sides = d_group[0]
+        "#{number}d#{sides}"
+      end
+      if fudge
+        d_array << "#{fudge}dF"
+      end
+      d_array
+    end
+    def roll
+      each do |die|
+        die.roll
+      end
+      self
+    end
+    def sum
+      inject(0) {|sum, d| sum + d.result}
+    end
+    def to_int
+      sum
+    end
+    def sets
+      result = {}
+      each do |die|
+        result[die.result] = count {|d| d.result == die.result}
+      end
+      result.sort_by{|height, width| [width, height] }.collect {|i| i[1].to_s+"x"+i[0].to_s}.reverse
+    end
+    def highest(n=1)
+      sorted = sort_by {|d| d.result}.reverse
+      Pool.new(sorted.first(n))
+    end
+    def lowest(n=1)
+      sorted = sort_by {|d| d.result}
+      Pool.new(sorted.first(n))
+    end
+    def drop_highest(n=1)
+      Pool.new(self-highest(n))
+    end
+    def drop_lowest(n=1)
+      Pool.new(self-lowest(n))
+    end
+    def drop(to_drop)
+      to_drop = [to_drop].flatten #turn it into an array if it isn't one.
+      kept = reject{|die| to_drop.any?{|drop_value| die.result == drop_value }}
+      return Pool.new(kept)
+    end
+    
+    private
+    def new_union(array)
+      union = [self, array].flatten
+      new_pool =[]
+      union.each do |die| 
+        if die.class == FudgeDie
+          new_pool << FudgeDie.new(die.result)
+        else
+          new_pool << Die.new(die.sides, die.result)
+        end
+      end
+      Pool.new(new_pool)
+    end
+  end
+end

data/lib/tabletop/version.rb

@@ -0,0 +1,3 @@
+module Tabletop
+  VERSION = "0.0.1"
+end

data/lib/tabletop.rb

@@ -0,0 +1,3 @@
+require_relative 'fixnum'
+require_relative 'tabletop/die'
+require_relative 'tabletop/pool'

data/spec/die_spec.rb

@@ -0,0 +1,189 @@
+require 'spec_helper'
+
+module Tabletop
+  describe Die do
+    before :each do
+      @d6_2 = Die.new(6, 2)
+      @d6_3 = Die.new(6, 3)
+    end
+    describe "#sides" do
+      it "can be accessed" do
+        d = Die.new(6)
+        d.sides.should == 6
+        d = Die.new(20)
+        d.sides.should == 20
+        d = Die.new(7)
+        d.sides.should equal(7)
+      end
+      it "is 6 by default" do
+        d = Die.new
+        d.sides.should equal(6)
+      end
+      it "cannot be 0 or less" do
+        lambda { Die.new(0) }.should raise_error(ArgumentError)
+        lambda { Die.new(-5) }.should raise_error(ArgumentError)
+      end
+      it "cannot be a non-integer" do
+        lambda { Die.new(0.1) }.should raise_error(ArgumentError)
+        lambda { Die.new(5.7694) }.should raise_error(ArgumentError)
+        lambda { Die.new("foof") }.should raise_error(ArgumentError)
+      end
+    end
+    describe "#result" do
+      before :each do
+        Random.srand(10)
+      end
+      it "should be random on instantiation by default" do 
+        d = Die.new
+        d.result.should equal(2)
+        d = Die.new(10)
+        d.result.should equal(5)
+        d = Die.new(50)
+        d.result.should equal(16)
+      end
+      it "can be set to a given value on instantiation" do
+        Die.new(6, 5).result.should == 5
+        Die.new(10, 2).result.should == 2
+      end
+      it "cannot be a non-integer" do
+        lambda { Die.new(0.1) }.should raise_error(ArgumentError)
+        lambda { Die.new(5.7694) }.should raise_error(ArgumentError)
+        lambda { Die.new("foof") }.should raise_error(ArgumentError)
+      end
+    end
+    describe "#result=" do
+      it "can only be set to an integer i, where 0 < i <= sides" do
+        d = Die.new
+        lambda { d.result = 0 }.should raise_error(ArgumentError)
+        lambda { d.result = -5 }.should raise_error(ArgumentError)
+        lambda { d.result = 7 }.should raise_error(ArgumentError)
+        d = Die.new(10)
+        d.result = 7
+        lambda { d.result = 22 }.should raise_error(ArgumentError)
+      end
+    end
+    describe "#roll" do
+      before(:each) do
+        Random.srand(10)
+      end
+      context "six sides" do
+        it "should return a random result between 1 and @sides" do
+          d = Die.new
+          #d.roll.should == 2 # This result gets swallowed by the init roll
+          d.roll.should == 6
+          d.roll.should == 5
+          d.roll.should == 1
+        end
+        it "should alter the result appropriately" do
+          d = Die.new
+          #d.roll # Covered by the initial roll
+          d.result.should == 2 
+          d.roll
+          d.result.should == 6
+          d.roll
+          d.result.should == 5
+          d.roll
+          d.result.should == 1
+        end
+      end
+      context "eleven sides" do
+        it "should return a random result between 1 and @sides" do 
+          d = Die.new(11)
+          # d.roll.should == 10 # This result gets swallowed by the init roll
+          d.roll.should == 5
+          d.roll.should == 1
+          d.roll.should == 2
+        end
+        it "should alter the result appropriately" do
+          d = Die.new(11)
+          #d.roll # covered by the initial roll
+          d.result.should == 10
+          d.roll
+          d.result.should == 5
+          d.roll
+          d.result.should == 1
+          d.roll
+          d.result.should == 2
+        end
+      end      
+    end
+    describe "#inspect" do
+      before(:each) do
+        Random.srand(10)
+      end
+      it "should be interesting" do
+        Die.new.inspect.should == "2 (d6)"
+        Die.new.inspect.should == "6 (d6)"
+      end
+    end
+    describe "#to_int" do
+      it "returns the result" do
+        d = Die.new
+        d.to_int.should == d.result
+      end
+    end
+    describe "<=>" do
+      it "compares numeric objects with the die's value" do
+        (@d6_3 < 4).should be_true
+        (@d6_3 < 2).should be_false
+        (@d6_3 > 2).should be_true
+        (@d6_3 > 4).should be_false
+        (@d6_3 >= 3).should be_true
+        (@d6_3 >= 10).should be_false
+        (@d6_3 <= 3).should be_true
+        (@d6_3 <= 2).should be_false
+        (@d6_3 == 3).should be_true
+        (@d6_3 == 6).should be_false
+      end
+      it "compares dice with each other by value" do
+        (@d6_3 > @d6_2).should be_true
+        (@d6_3 < @d6_2).should be_false
+        (@d6_2 < @d6_3).should be_true
+        (@d6_2 > @d6_3).should be_false
+        (@d6_3 == @d6_2).should be_false
+      end
+    end
+  end
+  describe FudgeDie do
+    before(:each) do
+      Random.srand(10)
+      @fudge = FudgeDie.new
+    end
+    describe "#sides" do
+      it "is always 3" do
+        @fudge.sides.should == 3
+      end
+    end
+    describe "#result" do
+      it "can be set on instantiation" do
+        FudgeDie.new(1).result.should == 1
+        FudgeDie.new(0).result.should == 0
+        FudgeDie.new(-1).result.should == -1
+      end
+      it "is randomly rolled if not set" do
+        @fudge.result.should == 0
+      end
+      it "can only be one of either -1, 0, or 1" do
+        lambda {FudgeDie.new(2)}.should raise_error(ArgumentError)
+        lambda {FudgeDie.new(0.6)}.should raise_error(ArgumentError)
+        lambda {FudgeDie.new("5")}.should raise_error(ArgumentError)
+      end
+    end
+    describe "#result=" do
+      it "cannot be set to anything but -1, 0, or 1" do
+        lambda {@fudge.result = 2}.should raise_error(ArgumentError)
+        lambda {@fudge.result = 0.6}.should raise_error(ArgumentError)
+        lambda {@fudge.result = "5"}.should raise_error(ArgumentError)
+        @fudge.result = 1
+        @fudge.result.should == 1
+      end
+    end
+    describe "#inspect" do
+      it "should look like plusses, minuses and spaces" do
+        FudgeDie.new(1).inspect.should == "[+] (dF)"
+        FudgeDie.new(0).inspect.should == "[ ] (dF)"
+        FudgeDie.new(-1).inspect.should == "[-] (dF)"
+      end
+    end
+  end
+end

data/spec/fixnum_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Tabletop
+  describe Fixnum do
+    describe "#dX" do
+      it "generates a pool of the appropriate size and type" do
+        1.d6.class.should == Pool
+        4.d7.dice.should == ["4d7"]
+        10.d100.class.should == Pool
+      end
+      it "shows up in respond_to?(:dN)" do
+        1.respond_to?(:d50).should be_true
+      end
+    end
+    describe "#dF" do
+      it "generates a pool of fudge dice" do
+        sotc = 4.dF
+        sotc.class.should == Pool
+        sotc.all? { |d| d.class == FudgeDie }.should be_true
+        sotc.dice.should == ["4dF"]
+      end
+    end
+  end
+end

data/spec/pool_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+module Tabletop
+  describe Pool do
+    before :each do
+      Random.srand(10)
+      @d6 = Pool.new("d6")
+      @d17s = Pool.new("5d17")
+      @mixed = Pool.new("2d10 d20") 
+      @fudge = Pool.new("3dF")
+    end
+    describe "#dice" do
+      it "should return an array of dice notation" do
+        @mixed.dice.should == ["2d10","d20"]
+        @d6.dice.should == ["d6"]
+        @d17s.dice.should == ["5d17"]
+        @fudge.dice.should == ["3dF"]
+        Pool.new("d20 2dF 2d10").dice.should == ["2d10","d20", "2dF"]
+      end
+    end
+    describe "[]" do
+      it "should access Die objects" do
+        @d6[0].class.should == Die
+        @fudge[0].class.should == FudgeDie
+      end
+    end
+    describe "+" do
+      it "should join Pools into new Pools" do
+        (@mixed + @d17s).class == Pool
+        (@d6 + @fudge).class == Pool
+      end
+      it "should persist die types" do
+        (@d6 + @fudge)[1].class.should == FudgeDie
+      end
+      it "should join pools without rolling them" do
+        merge = @d6 + @d17s
+        merge.results.should == [2, 5, 16, 1, 17, 9]
+        merge.roll
+        merge.results.should == [4, 17, 5, 16, 12, 12]
+      end
+      it "creates genuinely new pools" do
+        merge = @d6 + @d17s
+        merge.roll
+        @d6.results.should == [2]
+        @d17s.results.should == [5, 16, 1, 17, 9]
+      end
+      
+      it "should alter #dice accordingly" do
+        @d6 = Pool.new("d6")
+        @d17s = Pool.new("5d17")
+        @mixed = Pool.new("2d10 d20")
+        (@d6 + @d17s).dice.should == ["d6", "5d17"]
+        (@d17s + @d6).dice.should == ["d6", "5d17"]
+        (@d17s + @mixed).dice.should == ["2d10","5d17","d20"]
+        (@mixed + @fudge).dice.should == ["2d10", "d20", "3dF"]
+      end
+      it "should understand adding a number as looking for a sum result" do
+        (@d17s + 5).should == 53
+        (@mixed + @d6 + 10).should == 34
+        (@fudge + 3).should == 2
+      end
+      it "should add literal dice arrays as if they were pools" do
+        g = @d6 + [Die.new(6,3), Die.new(10, 4)]
+        g.results.should == [2, 3, 4]
+        g.dice.should == ["2d6", "d10"]
+        g.roll
+        @d6.results.should == [2]
+      end
+      it "should reject adding anything else" do
+        lambda {@d6 + "foof"}.should raise_error(ArgumentError)
+        lambda {@d6 + [Die.new, Object.new]}.should raise_error(ArgumentError)
+      end
+    end
+    describe "#results" do
+      it "should be an array of random numbers" do
+        @d6.results.should == [2]
+        @d17s.results.should == [5, 16, 1, 17, 9]
+        @mixed.results.should == [10, 1, 11]
+      end
+    end
+    describe "#roll" do
+      it "should return the Pool itself" do
+        @d6.roll.length.should == @d6.length
+        @d6.roll.class.should == @d6.class
+      end
+      it "should store the new values" do
+        @d6.roll
+        @d6.results.should == [4]
+        @d17s.roll
+        @d17s.results.should == [17, 5, 16, 12, 12]
+        @mixed.roll
+        @mixed.results.should == [2, 9, 5]
+      end
+    end
+    describe "#sum" do
+      it "should sum the dice values" do
+        @d6.sum.should == 2 
+        @d17s.sum.should == 48
+        @mixed.sum.should == 22
+        @fudge.sum.should == -1
+      end
+      it "should be aliased to #to_int" do
+        @d6.to_int.should == @d6.sum 
+        @d17s.to_int.should == @d17s.sum
+        @mixed.to_int.should == @mixed.sum
+        @fudge.to_int.should == @fudge.sum
+      end
+    end
+    describe "<=>" do
+      it "should compare the sums of different pools" do
+        @d17s.should >= @d6
+        @d6.should < Pool.new([Die.new(4, 4)])
+      end
+      it "should compare pools to numbers" do
+        @d6.should < 10
+        @d6.should == 2
+        @d17s.should <= 49
+      end
+    end
+    describe "#sets" do
+      it "should list the sets, in order by height and width" do
+        ore = Pool.new("10d10")
+        ore.sets.should == ["2x9", "2x5", "2x4", "2x2", "1x7", "1x1"]
+        ore.roll
+        ore.sets.should == ["3x10", "2x7", "1x6", "1x5", "1x4", "1x3", "1x2"]
+        ore.roll
+        ore.sets.should == ["3x9", "2x8", "2x7", "1x10", "1x3", "1x1"]
+      end
+    end
+    describe "#highest" do
+      it "should return a pool of the highest-value die" do
+        @d6.highest.class.should == Pool
+        @d6.highest.results.should == [2]
+        @d17s.highest.results.should == [17]
+        @mixed.highest.results.should == [11]
+      end
+      it "should return as many items as are specified" do
+        @d6.highest(5).results.should == [2]
+        @d17s.highest(3).results.should == [17, 16, 9]
+        @mixed.highest(2).results.should == [11, 10]
+      end
+    end
+    describe "#lowest" do
+      it "should return a pool of the lowest-value die." do
+        @d6.lowest.results.should == [2]
+        @d17s.lowest.class.should == Pool
+        @d17s.lowest.results.should == [1]
+        @mixed.lowest.results.should == [1]
+      end
+      it "should return as many items as are specified" do
+          @d6.lowest(5).results.should == [2]
+          @d17s.lowest(3).results.should == [1, 5, 9]
+          @mixed.lowest(2).results.should == [1, 10]
+      end
+    end
+    describe "#drop_highest" do
+      it "should return a new pool missing the highest result" do
+        p = @d17s.drop_highest
+        p.results.should == [5, 16, 1, 9]
+        @d17s.results.should == [5, 16, 1, 17, 9]
+      end
+      it "should drop as many items as are specified and are possible" do
+        p = @d17s.drop_highest(2)
+        p.results.should == [5, 1, 9]
+        p = @d6.drop_highest(10)
+        p.results.should == []
+      end
+    end
+    describe "#drop_lowest" do
+      it "should return a pool missing the lowest result" do
+        p = @d17s.drop_lowest
+        p.results.should == [5, 16, 17, 9]
+        @d17s.results.should == [5, 16, 1, 17, 9]
+      end
+      it "should drop as many items as are specified" do
+        p = @d17s.drop_lowest(2)
+        p.results.should == [16, 17, 9]
+      end
+    end
+    describe "#drop" do
+      it "should drop any dice of the specified value" do
+        ore = Pool.new("10d10")
+        ore.results.should == [4, 1, 5, 7, 9, 2, 9, 5, 2, 4]
+        at_least_two = ore.drop(1)
+        at_least_two.results.should == [4, 5, 7, 9, 2, 9, 5, 2, 4]
+        at_least_three = ore.drop([1,2])
+        at_least_three.results.should == [4, 5, 7, 9, 9, 5, 4]
+      end
+    end
+    context "pool has been emptied" do
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'bundler'
+begin
+  Bundler.setup
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+
+require 'rspec'
+require 'tabletop'
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  
+end

data/tabletop.gemspec

@@ -0,0 +1,33 @@
+$:.push File.expand_path("../lib", __FILE__)
+require 'tabletop/version'
+
+Gem::Specification.new do |s|
+  s.name = 'tabletop'
+  s.version = Tabletop::VERSION
+  s.platform = Gem::Platform::RUBY
+  s.date = '2011-08-10'
+  s.authors = ['Nick Novitski']
+  s.email = 'nicknovitski@gmail.com'
+  s.homepage = 'http://github.com/njay/tabletop'
+  s.summary = 'A Ruby DSL for role-playing games' 
+  s.description = 'Tabletop aims to provide a simple way of describing, automating and tracking the tools and tasks involved in "analog" games, determining results from the motions and properties of various dice and chips.'
+  s.extra_rdoc_files = [
+    'LICENSE',
+    'README.markdown',
+  ]
+
+  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.7')
+  s.rubygems_version = '1.3.7'
+  s.specification_version = 3
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {spec,features}/*`.split("\n")
+  s.require_paths = ['lib']
+
+  s.add_development_dependency 'rspec'
+  s.add_development_dependency 'bundler'
+  s.add_development_dependency 'bueller'
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'rdoc'
+end
+

metadata

@@ -0,0 +1,148 @@
+--- !ruby/object:Gem::Specification 
+name: tabletop
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Nick Novitski
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-10 00:00:00 -07:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: bundler
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  name: bueller
+  prerelease: false
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  name: rake
+  prerelease: false
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id004
+- !ruby/object:Gem::Dependency 
+  name: rdoc
+  prerelease: false
+  requirement: &id005 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  version_requirements: *id005
+description: Tabletop aims to provide a simple way of describing, automating and tracking the tools and tasks involved in "analog" games, determining results from the motions and properties of various dice and chips.
+email: nicknovitski@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .gitignore
+- Gemfile
+- LICENSE
+- README.markdown
+- Rakefile
+- lib/fixnum.rb
+- lib/tabletop.rb
+- lib/tabletop/die.rb
+- lib/tabletop/pool.rb
+- lib/tabletop/version.rb
+- spec/die_spec.rb
+- spec/fixnum_spec.rb
+- spec/pool_spec.rb
+- spec/spec_helper.rb
+- tabletop.gemspec
+has_rdoc: true
+homepage: http://github.com/njay/tabletop
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      segments: 
+      - 1
+      - 3
+      - 7
+      version: 1.3.7
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: A Ruby DSL for role-playing games
+test_files: 
+- spec/die_spec.rb
+- spec/fixnum_spec.rb
+- spec/pool_spec.rb
+- spec/spec_helper.rb