tablescript 0.0.4 → 1.0.0

data/lib/tablescript/table.rb

@@ -1,53 +1,75 @@
-# Copyright 2015 Jamie Hale
+# Copyright 2017 Jamie Hale
 #
-# This file is part of the Tablescript.rb gem.
+# This file is part of the Tablescript gem.
 #
-# Tablescript.rb is free software: you can redistribute it and/or modify
+# Tablescript is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Tablescript.rb is distributed in the hope that it will be useful,
+# Tablescript is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-    
-module TableScript
-  
+# along with Tablescript.  If not, see <http://www.gnu.org/licenses/>.
+
+module Tablescript
+  ##
+  # Table
+  #
   class Table
-  
-    attr_reader :entries
-  
-    def initialize( name, roller )
+    attr_reader :name, :entries
+
+    def initialize(name, namespace, &blk)
       @name = name
-      @roller = roller
-      @entries = nil
+      @namespace = namespace
+      @entries = TableEntries.new
+      instance_eval(&blk)
     end
-  
-    def build( &blk )
-      @entries = TableEntryEnvironment.new( @name, @roller )
-      @entries.instance_eval( &blk )
+
+    def f(roll = nil, &blk)
+      @entries.add_fixed(roll, &blk)
     end
-  
-    def random_entry
-      @roller.rollD( @entries.die_to_roll )
+
+    def d(count = 1, &blk)
+      @entries.add_dynamic(count, &blk)
     end
-  
-    def lookup( index )
-      @entries.lookup( index )
+
+    def lookup(roll)
+      @entries.lookup(roll).evaluate(roll, self)
     end
-  
-    def roll
-      @entries.reroll
+
+    def lookup_on(path, roll)
+      LookupStrategy.new(resolve(path.to_s), roll).value
     end
-    
-    def roll_and_ignore_duplicates( times, args )
-      @entries.reroll_and_ignore_duplicates( times, args )
+
+    def dice_to_roll
+      "d#{@entries.size}"
     end
-  
-  end
 
+    def roll_on(path)
+      RollStrategy.new(resolve(path.to_s)).value
+    end
+
+    def roll_on_and_ignore(path, *args)
+      RollAndIgnoreStrategy.new(resolve(path.to_s), RpgLib::RollSet.new(*args)).value
+    end
+
+    def roll_on_and_ignore_duplicates(path, times)
+      RollAndIgnoreDuplicatesStrategy.new(resolve(path.to_s), times).value
+    end
+
+    private
+
+    def resolve(path)
+      namespace = @namespace
+      until namespace.nil?
+        return namespace.resolve(path) if namespace.resolve?(path)
+        namespace = namespace.parent
+      end
+      raise Exception, "No such table #{path}"
+    end
+  end
 end

data/lib/tablescript/table_entries.rb

@@ -0,0 +1,66 @@
+module Tablescript
+  ##
+  # TableEntries
+  #
+  class TableEntries
+    def initialize
+      @entries = []
+      @next_id = 0
+    end
+
+    def size
+      @entries.size
+    end
+
+    def entry(index)
+      @entries[index]
+    end
+
+    def lookup(roll)
+      entry(roll - 1)
+    end
+
+    def add_fixed(roll, &blk)
+      if roll.nil?
+        add_entry(blk)
+      elsif roll.is_a?(Integer)
+        set_entry(roll, blk)
+      elsif roll.is_a?(Range)
+        set_range(roll, blk)
+      else
+        raise Exception, "Unrecognized parameter type (#{roll.class}) for fixed roll definition"
+      end
+    end
+
+    def add_dynamic(count, &blk)
+      range = next_single_roll..(next_single_roll + count - 1)
+      entry = TableEntry.new(next_id, range, blk)
+      count.times { @entries << entry }
+    end
+
+    private
+
+    def next_id
+      id = @next_id
+      @next_id += 1
+      id
+    end
+
+    def next_single_roll
+      @entries.size + 1
+    end
+
+    def add_entry(blk)
+      @entries << TableEntry.new(next_id, next_single_roll, blk)
+    end
+
+    def set_entry(roll, blk)
+      @entries[roll - 1] = TableEntry.new(next_id, roll, blk)
+    end
+
+    def set_range(range, blk)
+      entry = TableEntry.new(next_id, range, blk)
+      range.each { |r| @entries[r - 1] = entry }
+    end
+  end
+end

data/lib/tablescript/table_entry.rb

@@ -1,31 +1,35 @@
-# Copyright 2015 Jamie Hale
+# Copyright 2017 Jamie Hale
 #
-# This file is part of the Tablescript.rb gem.
+# This file is part of the Tablescript gem.
 #
-# Tablescript.rb is free software: you can redistribute it and/or modify
+# Tablescript is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Tablescript.rb is distributed in the hope that it will be useful,
+# Tablescript is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-    
-module TableScript
-  
+# along with Tablescript.  If not, see <http://www.gnu.org/licenses/>.
+
+module Tablescript
+  ##
+  # TableEntry
+  #
   class TableEntry
-    
-    def initialize( blk )
+    attr_reader :id, :roll, :blk
+
+    def initialize(id, roll, blk)
+      @id = id
+      @roll = roll
       @blk = blk
     end
-    
-    def evaluate( roll )
-      @blk.call( roll )
+
+    def evaluate(roll, table)
+      table.instance_exec(RollContext.new(roll, table, self), &@blk)
     end
   end
-
 end

data/lib/tablescript/version.rb

@@ -1,20 +1,20 @@
-# Copyright 2015 Jamie Hale
+# Copyright 2017 Jamie Hale
 #
-# This file is part of the Tablescript.rb gem.
+# This file is part of the Tablescript gem.
 #
-# Tablescript.rb is free software: you can redistribute it and/or modify
+# Tablescript is free software: you can redistribute it and/or modify
 # it under the terms of the GNU General Public License as published by
 # the Free Software Foundation, either version 3 of the License, or
 # (at your option) any later version.
 #
-# Tablescript.rb is distributed in the hope that it will be useful,
+# Tablescript is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU General Public License
-# along with Foobar.  If not, see <http://www.gnu.org/licenses/>.
-    
-module TableScript
-  VERSION = "0.0.4"
+# along with Tablescript.  If not, see <http://www.gnu.org/licenses/>.
+
+module Tablescript
+  VERSION = '1.0.0'.freeze
 end

data/spec/spec_helper.rb

@@ -0,0 +1,4 @@
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'simplecov'
+SimpleCov.start
+require 'tablescript'

data/spec/tablescript/api_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+module Tablescript
+  describe Api do
+    let(:api) { Class.new { include Api }.new }
+
+    describe 'table' do
+    end
+
+    describe 'rolling' do
+      let(:values) { %w(red green blue) }
+
+      before(:each) do
+        Library.instance = Library.new
+        api.table :colours do
+          f { 'red' }
+          f { 'green' }
+          f { 'blue' }
+        end
+      end
+
+      describe 'roll_on' do
+        it 'rolls on the table' do
+          10.times do
+            expect(values).to include(api.roll_on(:colours))
+          end
+        end
+      end
+
+      describe 'roll_on_and_ignore' do
+        it 'rolls on the table and ignores certain rolls' do
+          10.times do
+            expect(%w(red blue)).to include(api.roll_on_and_ignore(:colours, 2))
+          end
+        end
+      end
+
+      describe 'roll_on_and_ignore_duplicates' do
+        before(:each) do
+          @results = []
+          10.times do
+            @results << api.roll_on_and_ignore_duplicates(:colours, 2)
+          end
+        end
+
+        it 'returns the expected number of results' do
+          @results.each do |roll_results|
+            expect(roll_results.size).to eq(2)
+          end
+        end
+
+        it 'ignores duplicate rolls' do
+          @results.each do |roll_results|
+            expect(roll_results[0]).not_to eq(roll_results[1])
+          end
+        end
+      end
+
+      describe 'lookup' do
+        it 'returns the specified entry' do
+          expect(api.lookup(:colours, 2)).to eq('green')
+        end
+      end
+    end
+  end
+end

data/spec/tablescript/library_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+module Tablescript
+  describe Library do
+    it 'is a singleton' do
+      expect { Library.instance }.not_to raise_error
+    end
+
+    it 'knows its root namespace' do
+      expect(Library.instance.root).to be_a(Namespace)
+    end
+  end
+end

data/spec/tablescript/lookup_strategy_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+module Tablescript
+  describe LookupStrategy do
+    it 'can be created' do
+      expect { LookupStrategy.new(:table, :roll) }.not_to raise_error
+    end
+
+    describe 'value' do
+      let(:table) { double('table') }
+      let(:roll) { 6 }
+      let(:value) { 'Vorpal sword' }
+      let(:strategy) { LookupStrategy.new(table, roll) }
+
+      before(:each) do
+        allow(table).to receive(:evaluate) { value }
+        @value = strategy.value
+      end
+
+      it 'defers to the table' do
+        expect(table).to have_received(:evaluate).with(roll)
+      end
+
+      it 'provides the tables result' do
+        expect(@value).to eq(value)
+      end
+
+      it 'does not evaluate twice' do
+        strategy.value
+        strategy.value
+        expect(table).to have_received(:evaluate).once
+      end
+    end
+  end
+end

data/spec/tablescript/namespace_spec.rb

@@ -0,0 +1,25 @@
+module Tablescript
+  describe Namespace do
+    describe 'add' do
+      let(:table) { double('table', name: :table) }
+      let(:namespace) { Namespace.new }
+
+      it 'knows it has added table' do
+        namespace.add(table)
+        expect(namespace.table?(:table)).to be true
+      end
+
+      it 'retrieves the table' do
+        namespace.add(table)
+        expect(namespace.table(:table)).to eq(table)
+      end
+
+      describe 'duplicates' do
+        it 'throws when trying to add a duplicate' do
+          namespace.add(table)
+          expect { namespace.add(table) }.to raise_error(Exception)
+        end
+      end
+    end
+  end
+end

data/spec/tablescript/roll_and_ignore_strategy_spec.rb

@@ -0,0 +1,57 @@
+require 'spec_helper'
+
+module Tablescript
+  describe RollAndIgnoreStrategy do
+    it 'can be created' do
+      expect { RollAndIgnoreStrategy.new(:table, :rollset) }.not_to raise_error
+    end
+
+    describe 'evaluate' do
+      let(:dice) { 'd20' }
+      let(:table) { double('table', dice_to_roll: dice) }
+      let(:rollset) { double('rollset') }
+      let(:roll) { 6 }
+      let(:value) { 'Vorpal sword' }
+      let(:roller) { RpgLib::DiceRoller.clone.instance }
+      let(:strategy) { RollAndIgnoreStrategy.new(table, rollset, roller) }
+
+      before(:each) do
+        allow(roller).to receive(:roll_and_ignore) { roll }
+        allow(table).to receive(:evaluate) { value }
+        @value = strategy.value
+      end
+
+      it 'defers to the roller' do
+        expect(roller).to have_received(:roll_and_ignore).with(dice, rollset)
+      end
+
+      it 'defers to the table' do
+        expect(table).to have_received(:evaluate).with(roll)
+      end
+
+      describe 'value' do
+        it 'provides the tables result' do
+          expect(@value).to eq(value)
+        end
+
+        it 'only evaluates once' do
+          strategy.value
+          strategy.value
+          expect(table).to have_received(:evaluate).once
+        end
+      end
+
+      describe 'roll' do
+        it 'knows its roll' do
+          expect(strategy.roll).to eq(roll)
+        end
+
+        it 'only evaluates once' do
+          strategy.roll
+          strategy.roll
+          expect(table).to have_received(:evaluate).once
+        end
+      end
+    end
+  end
+end