tabletop 0.1.0 → 0.2.0

data/Rakefile

@@ -15,14 +15,10 @@ rescue Bundler::BundlerError => e
 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'
@@ -35,3 +31,32 @@ RDoc::Task.new do |rdoc|
   rdoc.rdoc_files.include('README*')
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
+
+gemspec = eval(File.read(Dir["*.gemspec"].first))
+desc "Validate the gemspec"
+task :gemspec do
+  gemspec.validate
+end
+
+desc "Build gem locally"
+task :build => :gemspec do
+  system "gem build #{gemspec.name}.gemspec"
+  FileUtils.mkdir_p "pkg"
+  FileUtils.mv "#{gemspec.name}-#{gemspec.version}.gem", "pkg"
+end
+ 
+desc "Install gem locally"
+task :install => :build do
+  system "gem install pkg/#{gemspec.name}-#{gemspec.version}"
+end
+
+desc "Clean automatically generated files"
+task :clean do
+  FileUtils.rm_rf "pkg"
+end
+
+desc "Push changes to github and rubygems"
+task :publish do
+  system "git push origin master --tags"
+  system "gem push pkg/#{gemspec.name}-#{gemspec.version}"
+end

data/lib/tabletop/pool.rb

@@ -1,11 +1,11 @@
-require_relative 'die'
+require_relative 'randomizers'
 require 'delegate'
 
 module Tabletop
   class Pool < DelegateClass(Array)
     include Comparable
     def initialize(init_dice)
-      return super(init_dice) if init_dice.class == Array
+      return super(init_dice) if init_dice.instance_of?(Array)
       d_groups = init_dice.split
       dice = []
       d_groups.each do |d_notation|
@@ -20,9 +20,10 @@ module Tabletop
       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}))
+      if operand.instance_of?(Pool) or (operand.instance_of?(Array) and !(operand.detect{|obj| !(obj.instance_of?(Die))}))
         new_union(operand)
       elsif operand.kind_of? Numeric
         sum + operand
@@ -35,6 +36,14 @@ module Tabletop
         sum <=> operand.to_int
     end
       
+    def *(operand)
+      sum * operand
+    end
+    
+    def coerce(other)
+      [other, sum]
+    end
+    
     def values
       map {|die| die.value}
     end
@@ -42,8 +51,8 @@ module Tabletop
       fudge = nil
       result = {}
       each do |die|
-        if die.class == FudgeDie
-          fudge = count {|d| d.class == FudgeDie}
+        if die.instance_of?(FudgeDie)
+          fudge = count {|d| d.instance_of?(FudgeDie)}
         else
           result[die.sides] = count {|d| d.sides == die.sides}
         end
@@ -101,7 +110,7 @@ module Tabletop
       union = [self, array].flatten
       new_pool =[]
       union.each do |die| 
-        if die.class == FudgeDie
+        if die.instance_of?(FudgeDie)
           new_pool << FudgeDie.new(die.value)
         else
           new_pool << Die.new(die.sides, die.value)

data/lib/tabletop/{die.rb → randomizers.rb}

@@ -59,4 +59,28 @@ module Tabletop
       [1,0,-1].include?(val)
     end
   end
+  
+  class Coin < Die
+    def initialize(value=nil)
+      super(2, value)
+    end
+    
+    def roll
+      @value = rand(sides)
+    end
+    
+    def flip
+      roll
+      self
+    end
+    
+    def to_s
+      "(#{[' ', '+'][value]})"
+    end
+    
+    protected
+    def valid_value?(val)
+      [0,1].include?(val)
+    end
+  end
 end

data/lib/tabletop/roll.rb

@@ -40,7 +40,7 @@ module Tabletop
       @possibilities.each do |poss|
         if meets?(poss)
           poss.outcomes.each do |outcome|
-            if Roll === outcome
+            if outcome.instance_of?(Roll)
               results << outcome.roll.effects
             else
               results << outcome
@@ -98,7 +98,7 @@ module Tabletop
     end
     
     def equals(values, *outcomes)
-      if values.class == Range
+      if values.instance_of?(Range)
         values.each do |val|
           @possibilities << Possibility.new(outcomes, :== => val)
         end

data/lib/tabletop/token.rb

@@ -0,0 +1,47 @@
+module Tabletop
+  
+  class NotEnoughTokensError < ArgumentError
+  end
+  
+  class TokenStack
+    attr_accessor :count
+    include Comparable
+    
+    def initialize(n = 1)
+      @count = n
+    end
+    
+    def <=>(operand)
+        count <=> operand.to_int
+    end
+    
+    def add(n = 1)
+      raise ArgumentError unless n.instance_of?(Fixnum) and n > 0
+      @count += n
+    end
+    
+    def remove(n=1)
+      raise ArgumentError unless n.instance_of?(Fixnum) and n > 0
+      if n > @count
+        n_t, c_t = "token", "token"
+        
+        n_t << "s" if n > 1 or n == 0
+        
+        c_t << "s" if @count > 1 or @count == 0
+        
+        c = @count > 0 ? @count : "no" 
+        errmsg = "tried to remove #{n} #{n_t} from a stack with #{c} #{c_t}"
+        raise NotEnoughTokensError, errmsg
+      end
+      @count -= n
+    end
+    
+    def move(n, opts)
+      raise(ArgumentError, "target is #{opts[:to].class}, not TokenStack") unless opts[:to].instance_of?(TokenStack)
+      remove(n)
+      opts[:to].add(n)
+    end
+  end
+  
+
+end

data/lib/tabletop/version.rb

@@ -1,3 +1,3 @@
 module Tabletop
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/tabletop.rb

@@ -1,4 +1,5 @@
 require_relative 'fixnum'
-require_relative 'tabletop/die'
+require_relative 'tabletop/randomizers'
 require_relative 'tabletop/pool'
 require_relative 'tabletop/roll'
+require_relative 'tabletop/token'

data/spec/fixnum_spec.rb

@@ -4,20 +4,21 @@ module Tabletop
   describe Fixnum do
     describe "#dX" do
       it "generates a pool of the appropriate size and type" do
-        1.d6.class.should == Pool
+        1.d6.should be_instance_of(Pool)
         4.d7.dice.should == ["4d7"]
-        10.d100.class.should == Pool
+        10.d100.should be_instance_of(Pool)
       end
       
       it "shows up in respond_to?(:dN)" do
-        1.respond_to?(:d50).should be_true
+        1.should respond_to(:d50)
+        10.should_not respond_to(:dthing)
       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.should be_instance_of(Pool)
+        sotc.all? { |d| d.instance_of?(FudgeDie) }.should be_true
         sotc.dice.should == ["4dF"]
       end
     end

data/spec/pool_spec.rb

@@ -22,19 +22,19 @@ module Tabletop
     
     describe "[]" do
       it "should access Die objects" do
-        @d6[0].class.should == Die
-        @fudge[0].class.should == FudgeDie
+        @d6[0].should be_instance_of(Die)
+        @fudge[0].should be_instance_of(FudgeDie)
       end
     end
     
     describe "+" do
       it "should join Pools into new Pools" do
-        (@mixed + @d17s).class == Pool
-        (@d6 + @fudge).class == Pool
+        (@mixed + @d17s).should be_instance_of(Pool)
+        (@d6 + @fudge).should be_instance_of(Pool)
       end
       
       it "should persist die types" do
-        (@d6 + @fudge)[1].class.should == FudgeDie
+        (@d6 + @fudge)[1].should be_instance_of(FudgeDie)
       end
       
       it "should join pools without rolling them" do
@@ -76,8 +76,18 @@ module Tabletop
       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)
+        expect {@d6 + "foof"}.to raise_error(ArgumentError)
+        expect {@d6 + [Die.new, Object.new]}.to raise_error(ArgumentError)
+      end
+    end
+    
+    describe "*" do
+      it "should multiply by the sum of the pool" do
+        (1..10).each do |v|
+          p = Pool.new([Die.new(10, v)])
+          (p * 5).should == (v * 5)
+          (5 * p).should == (5 * v)
+        end
       end
     end
     
@@ -92,7 +102,7 @@ module Tabletop
     describe "#roll" do
       it "should return the Pool itself" do
         @d6.roll.length.should == @d6.length
-        @d6.roll.class.should == @d6.class
+        @d6.roll.should be_instance_of(Pool)
       end
       
       it "should store the new values" do
@@ -150,7 +160,7 @@ module Tabletop
     
     describe "#highest" do
       it "should return a pool of the highest-value die" do
-        @d6.highest.class.should == Pool
+        @d6.highest.should be_instance_of(Pool)
         @d6.highest.values.should == [2]
         @d17s.highest.values.should == [17]
         @mixed.highest.values.should == [11]
@@ -166,7 +176,7 @@ module Tabletop
     describe "#lowest" do
       it "should return a pool of the lowest-value die." do
         @d6.lowest.values.should == [2]
-        @d17s.lowest.class.should == Pool
+        @d17s.lowest.should be_instance_of(Pool)
         @d17s.lowest.values.should == [1]
         @mixed.lowest.values.should == [1]
       end

data/spec/{die_spec.rb → randomizers_spec.rb}

@@ -20,15 +20,15 @@ module Tabletop
       end
       
       it "cannot be 1 or less" do
-        lambda { Die.new(0) }.should raise_error(ArgumentError)
-        lambda { Die.new(1) }.should raise_error(ArgumentError)
-        lambda { Die.new(-5) }.should raise_error(ArgumentError)
+        expect { Die.new(0) }.to raise_error(ArgumentError)
+        expect { Die.new(1) }.to raise_error(ArgumentError)
+        expect { Die.new(-5) }.to 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)
+        expect { Die.new(0.1) }.to raise_error(ArgumentError)
+        expect { Die.new(5.7694) }.to raise_error(ArgumentError)
+        expect { Die.new("foof") }.to raise_error(ArgumentError)
       end
     end
     
@@ -46,9 +46,9 @@ module Tabletop
       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)
+        expect { Die.new(0.1) }.to raise_error(ArgumentError)
+        expect { Die.new(5.7694) }.to raise_error(ArgumentError)
+        expect { Die.new("foof") }.to raise_error(ArgumentError)
       end
     end
     
@@ -144,17 +144,17 @@ module Tabletop
         [-1, 0, 1].each do |v|
           FudgeDie.new(v)
         end
-        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)
+        expect {FudgeDie.new(2)}.to raise_error(ArgumentError)
+        expect {FudgeDie.new(0.6)}.to raise_error(ArgumentError)
+        expect {FudgeDie.new("5")}.to raise_error(ArgumentError)
       end
     end
     
     describe "#value=" do
       it "cannot be set to anything but -1, 0, or 1" do
-        lambda {@fudge.value = 2}.should raise_error(ArgumentError)
-        lambda {@fudge.value = 0.6}.should raise_error(ArgumentError)
-        lambda {@fudge.value = "5"}.should raise_error(ArgumentError)
+        expect {@fudge.value = 2}.to raise_error(ArgumentError)
+        expect {@fudge.value = 0.6}.to raise_error(ArgumentError)
+        expect {@fudge.value = "5"}.to raise_error(ArgumentError)
         [-1, 0, 1].each do |v|
           @fudge.value = v
         end
@@ -169,4 +169,36 @@ module Tabletop
       end
     end
   end
+  
+  describe Coin do
+    describe "#sides" do
+      it {subject.sides.should == 2}
+    end
+    
+    describe "#value" do
+      it "can be either 0 or 1" do
+        [0, 1].each do |v|
+          subject.value = v
+        end
+      end
+      
+      it "can't be anything else" do
+        expect {subject.value = "a thing"}.to raise_error(ArgumentError)
+        expect {subject.value = 2}.to raise_error(ArgumentError)
+      end
+    end
+    
+    describe "#flip" do
+      it {subject.flip.should be_instance_of(Coin)}
+      it "should alias roll" do
+        subject.should_receive(:roll)
+        subject.flip
+      end
+    end
+    
+    describe "#to_s" do
+      it {Coin.new(1).to_s.should == "(+)"}
+      it {Coin.new(0).to_s.should == "( )"}
+    end
+  end
 end

data/spec/roll_spec.rb

@@ -7,7 +7,7 @@ module Tabletop
       it "accesses the roll's pool" do
         d20 = Roll.new(1.d20) do
         end
-        d20.pool.class.should == Pool
+        d20.pool.should be_instance_of(Pool)
         d20.pool.length.should == 1
         d20.pool[0].sides.should == 20
       end
@@ -61,7 +61,7 @@ module Tabletop
           end
           @exalted.roll(:pool=>10)
           @exalted.pool.length.should == 10
-          lambda {@exalted.roll}.should raise_error(ArgumentError)
+          expect {@exalted.roll}.to raise_error(ArgumentError)
         end
         
         it "can count successes" do
@@ -111,7 +111,7 @@ module Tabletop
         
         [1,2,3].include?(c[0]).should be_true
         
-        b[1].class.should == String
+        b[1].should be_instance_of(String)
         
       end
       before :each do

data/spec/token_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+
+module Tabletop
+  describe TokenStack do
+
+    describe "#count" do
+      it {subject.count.should == 1}
+      
+      it "can be set on instantiation" do
+        (1..5).each do |v|
+          TokenStack.new(v).count.should == v
+        end
+      end
+      
+      it "is called when stacks are compared to numbers" do
+        (1..5).each do |v|
+          s = TokenStack.new(v)
+          s.should == v
+          s.should >= v-1
+          s.should <= v+1
+        end
+      end
+    end
+
+    describe "#add" do
+
+      context "when called without arguments" do
+        it "increases the count by 1" do
+          subject.add
+          subject.count.should == 2
+        end
+      end
+
+      context "when called with one argument" do
+        it "increases the count by that argument" do
+          subject.add(2)
+          subject.count.should == 3
+          (1..5).each do |i|
+            expect {
+              subject.add(i)
+            }.to change{subject.count}.by(i)
+          end
+        end
+        
+        it "does not accept non-integers" do
+          expect { subject.add(0.1) }.to raise_error(ArgumentError)
+        end
+        
+        it "does not accept arguments < 1" do
+          expect { subject.add(0) }.to raise_error(ArgumentError)
+          expect { subject.add(-1) }.to raise_error(ArgumentError)
+          subject.add(1)
+        end
+      end
+    end
+    describe "#remove" do
+      context "when called without arguments" do
+        it "decreases the count by 1" do
+          subject.remove
+          subject.count.should == 0
+        end
+      end
+
+      context "when called with one argument" do
+        it "decreases the count by that argument" do
+          (1..5).each do |i|
+            s = TokenStack.new(5)
+            expect {s.remove(i)}.to change{s.count}.by(-i)
+          end
+        end
+        
+        it "does not accept non-integers" do
+          expect { subject.remove(0.1) }.to raise_error(ArgumentError)
+        end
+        
+        it "does not accept arguments < 1" do
+          expect { subject.remove(0) }.to raise_error(ArgumentError)
+          expect { subject.remove(-1) }.to raise_error(ArgumentError)
+          subject.remove(1)
+        end
+        
+        it "raises an error when trying to remove too many" do
+          expect { subject.remove(2) }.to raise_error(
+            NotEnoughTokensError,
+            /tried to remove 2 tokens from a stack with 1 token/)
+          expect { TokenStack.new(2).remove(3) }.to raise_error(
+            NotEnoughTokensError,
+            /tried to remove 3 tokens from a stack with 2 tokens/)
+          expect { TokenStack.new(0).remove(1) }.to raise_error(
+            NotEnoughTokensError,
+            /tried to remove 1 token from a stack with no tokens/)
+        end
+      end
+    end
+    describe "#move" do
+      before :each do
+        @a = TokenStack.new
+        @b = TokenStack.new
+      end
+      it "removes tokens from the receiving stack" do
+        (1..10).each do |v|
+          @a.add(v)
+          expect {@a.move(v, :to =>@b)}.to change{@a.count}.by(-v)
+        end
+      end
+      it "adds tokens to the stack passed as the :to argument" do
+        (1..10).each do |v|
+          @a.add(v)
+          expect {@a.move(v, :to =>@b)}.to change{@b.count}.by(v)
+        end
+      end
+      it "doesn't move any tokens if :to isn't a TokenStack" do
+        expect {@a.move(1, :to => [])}.to raise_error(
+          ArgumentError,
+          /target is Array, not TokenStack/)
+        @a.count.should == 1
+        @b.count.should == 1
+      end
+    end
+  end
+end

data/tabletop.gemspec

@@ -16,8 +16,7 @@ Gem::Specification.new do |s|
     'README.markdown',
   ]
 
-  s.required_rubygems_version = Gem::Requirement.new('>= 1.3.7')
-  s.rubygems_version = '1.3.7'
+  s.required_rubygems_version = '>= 1.3.7'
   s.specification_version = 3
 
   ignores = File.readlines(".gitignore").grep(/\S+/).map {|s| s.chomp }
@@ -29,7 +28,6 @@ Gem::Specification.new do |s|
 
   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

@@ -2,7 +2,7 @@
 name: tabletop
 version: !ruby/object:Gem::Version 
   prerelease: 
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors: 
 - Nick Novitski
@@ -35,7 +35,7 @@ dependencies:
   prerelease: false
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
-  name: bueller
+  name: rake
   requirement: &id003 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -46,7 +46,7 @@ dependencies:
   prerelease: false
   version_requirements: *id003
 - !ruby/object:Gem::Dependency 
-  name: rake
+  name: rdoc
   requirement: &id004 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
@@ -56,17 +56,6 @@ dependencies:
   type: :development
   prerelease: false
   version_requirements: *id004
-- !ruby/object:Gem::Dependency 
-  name: rdoc
-  requirement: &id005 !ruby/object:Gem::Requirement 
-    none: false
-    requirements: 
-    - - ">="
-      - !ruby/object:Gem::Version 
-        version: "0"
-  type: :development
-  prerelease: false
-  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: []
@@ -79,19 +68,21 @@ extra_rdoc_files:
 files: 
 - Gemfile
 - lib/fixnum.rb
-- lib/tabletop/die.rb
 - lib/tabletop/pool.rb
+- lib/tabletop/randomizers.rb
 - lib/tabletop/roll.rb
+- lib/tabletop/token.rb
 - lib/tabletop/version.rb
 - lib/tabletop.rb
 - LICENSE
 - Rakefile
 - README.markdown
-- spec/die_spec.rb
 - spec/fixnum_spec.rb
 - spec/pool_spec.rb
+- spec/randomizers_spec.rb
 - spec/roll_spec.rb
 - spec/spec_helper.rb
+- spec/token_spec.rb
 - tabletop.gemspec
 - .gitignore
 homepage: http://github.com/njay/tabletop
@@ -107,7 +98,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements: 
   - - ">="
     - !ruby/object:Gem::Version 
-      hash: -2668007910377914487
+      hash: 3490526089610525128
       segments: 
       - 0
       version: "0"
@@ -125,8 +116,9 @@ 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/randomizers_spec.rb
 - spec/roll_spec.rb
 - spec/spec_helper.rb
+- spec/token_spec.rb