snakes_and_ladders 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0f2c16f3b1a14cc698be0bba9d33de259cdff5c
+  data.tar.gz: 48566fe26a8518f5e54f393cc1bdcf6053010384
+SHA512:
+  metadata.gz: 7786ee623a842528548f0f3768dc8eaafdd4415b9e2fc2803648f162b6c27c5078cf0fcd201697c389ef126d7438be4728765fddb9a633ea7edc0c80ecbf507f
+  data.tar.gz: ce2ea4b033ae9e0766723033057332354be8816d40434c18ddbccd8c70fd89b2e2cf0684d1a8fb97c041cfbb9050410ad36f470b964fe83566b0c1b4eb5b27a0

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,3 @@
+--color
+--warnings
+--require spec_helper

data/Gemfile

@@ -0,0 +1,6 @@
+ruby "2.1.2"
+
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in snakes_and_ladders.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 Mohamad El-Husseini
+
+MIT License
+
+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,156 @@
+# SnakesAndLadders
+
+This gem is a CLI clone of the classic board game [Snakes and Ladders][1] (or Chutes and Ladders). It's written in Ruby, and uses the Object-oriented programming paradigm.
+
+This gem uses features only available in **Ruby 2.1** and above, such as *keyword arguments*, and *required keyword arguments*. You will need Ruby 2.1 to run this gem.
+
+## Table of Contents
+- [About the Game][game]
+- [Installation][installation]
+- [Playing the Game][playing]
+- [Simulating Games][simulating]
+- [Extensibility and Building Custom Boards][extensibility]
+- [Rendering][rendering]
+- [Contributing][contributing]
+
+## About the Game
+
+From the Snakes and Ladders [Wikipedia entry][1]:
+
+>Snakes and Ladders is an ancient Indian board game regarded today as a worldwide classic. It is played between two or more players on a gameboard having numbered, gridded squares. A number of "ladders" and "snakes" are pictured on the board, each connecting two specific board squares. The object of the game is to navigate one's game piece, according to die rolls, from the start (bottom square) to the finish (top square), helped or hindered by ladders and snakes respectively. The historic version had root in morality lessons, where a player's progression up the board represented a life journey complicated by virtues (ladders) and vices (snakes).
+
+This implementation is feature complete except for one rule: Rolling three sixes consecutively will not send you back to square one. Like the original, landing on or rolling in excess of the last square will cause you to win.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'snakes_and_ladders'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install snakes_and_ladders
+
+## Playing
+
+First, create some players. Unlike its physical counterpart, this implementation has no player limit; you can play with as many players as you want.
+
+````ruby
+peach = SnakesAndLadders.new_player(name: "Peach", color: "Pink")
+luigi = SnakesAndLadders.new_player(name: "Luigi", color: "Green")
+````
+
+Now we need a game instance. The game ships with the classic board (based on Milton Bradley edition, 1952). You can create your own boards using the Grid class. A random board generator will soon become available.
+
+````ruby
+game = SnakesAndLadders.classic([peach, luigi])
+````
+
+Now let's roll the die to play.
+
+````ruby
+game.play_turn
+# => Peach rolls 1.
+# => Peach moves to square 1 and takes a ladder!
+# => Peach is on square 38.
+game.play_turn
+# => Luigi rolls 5.
+# ...
+````
+
+## Simulating Games
+
+You can simulate entire games from start to finish without having to call `play_turn`. At any time you can call `game.simulate`, and the game will play itself to the end. You can simulate games before and after they have started.
+
+````ruby
+game.simulate
+# => Peach rolls a 5!
+# => Peach is on square 43.
+# => Luigi rolls 2!
+# => Luigi moves to square 80 and takes a ladder!
+# => Luigi is on square 100.
+# => Game over! Luigi wins in 14 turns. Congratulations!
+````
+
+## Extensibility
+
+The game is fairly extensible and additional tiles to cell, snake, and ladder are pluggable. You can create additional tiles by inheriting from `SnakesAndLadders::Cell` and overriding the `enter` and `exit` methods where necessary.
+
+````ruby
+module SnakesAndLadders
+  class Bowser < Cell
+    def initialize(location: location)
+      super
+    end
+
+    def enter(player, board)
+      player.kidnap!
+      puts "#{player} was kidnapped by evil Bower. Bwahahahaha!"
+      super
+    end
+  end
+end
+````
+
+In this example we created a new tile called Bowser. It kidnaps any player that lands on it. The implementation of kidnap is not important for the purpose of this example.
+
+### Creating Custom Boards
+
+Our Bowser tile is not going to use itself. We have to build a board and tell it where to place Bowser tiles. We can do this using the packaged builder. The `Grid` class is responsible for mounting new boards. It accepts an array of tile mappings.
+
+````ruby
+mappings = [
+ { class: :Portal, location: 1, destination: 38 },
+ { class: :Bowser, location: 5 },
+ { class: :Portal, location: 16, destination: 6 },
+ # ...
+]
+````
+
+A mapping is just a hash of attributes that represent a tile. A mapping *must contain* `class` and `location` keys. You only have to create mappings for custom tiles. The grid will fill any missing locations with a normal `Cell` objects (this behaviour is also customisable by passing in a custom `default_tile` argument).
+
+Our example mappings will produce the following board. The numbers denote tile numbers.
+
+````
+| 1. Portal | 2. Cell | 3. Cell | 4. Cell | 5. Bowser | 6. Cell ... | 16. Portal |
+````
+
+If you are wondering what `Portal` is, it's a class that represents snakes and ladders. Snakes and ladders have identical behaviour. Only their data differs. In the case of a snake, its destination is always smaller than its location. The opposite is true for ladders. So we can use the same class to represent both. You can think of them as portals because they transport players to other locations; *where to* is secondary.
+
+Once we have our mappings we tell the grid to mount them.
+
+````ruby
+tiles = SnakesAndLadders::Grid.new(size: 100, tile_mappings: mappings).build
+board = SnakesAndLadders::Board.new(grid: tiles)
+game = SnakesAndLadders::Game.new(board: board, players: players)
+````
+
+Now our game will use our shiny new Bowser tile. Needless to say you should only create mappings for classes that you have built.
+
+## Rendering
+
+The game has no built in renderer. But any instance of Game contains all the information needed to render the game, so it's relatively easy to create your own render.
+
+## Contributing
+
+If you fancy a crack at creating a terminal renderer class, please go ahead. I'm also always looking for code reviews.
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+
+  [1]: http://en.wikipedia.org/wiki/Snakes_and_Ladders
+  [game]: #about-the-game
+  [installation]: #installation
+  [playing]: #playing
+  [simulating]: #simulating-games
+  [extensibility]: #extensibility
+  [rendering]: #rendering
+  [contributing]: #contributing

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+task :console do
+  exec "irb -r snakes_and_ladders -I ./lib"
+end

data/lib/snakes_and_ladders/board.rb

@@ -0,0 +1,26 @@
+module SnakesAndLadders
+  class Board
+    attr_reader :grid
+
+    def initialize(grid: Grid.classic)
+      @grid = grid
+    end
+
+    def move(player, from, to)
+      if destination = get_cell(to)
+        if location = get_cell(from)
+          location.exit(player)
+        end
+        destination.enter(player, self)
+      end
+    end
+
+    def get_cell(index)
+      grid[index]
+    end
+
+    def size
+      grid.size
+    end
+  end
+end

data/lib/snakes_and_ladders/cell.rb

@@ -0,0 +1,19 @@
+module SnakesAndLadders
+  class Cell
+    attr_reader :location, :players
+
+    def initialize(location:, players: [])
+      @location = location
+      @players = players
+    end
+
+    def exit(player)
+      players.delete(player)
+    end
+
+    def enter(player, board)
+      players.push(player) && player.position = location
+      puts "#{player} is on square #{location}."
+    end
+  end
+end

data/lib/snakes_and_ladders/game.rb

@@ -0,0 +1,58 @@
+module SnakesAndLadders
+  class Game
+    attr_reader :board, :players, :winner, :turn, :player
+
+    def initialize(board:, players: [], turn: 0)
+      @board = board
+      @players = players
+      @turn = turn
+    end
+
+    def add_player(player)
+      players.push(player)
+    end
+
+    def play_turn
+      return if over?
+
+      init_turn
+
+      puts "#{player} rolls #{player.last_roll}!"
+
+      if board.move(player, player.position, player.destination_after_last_roll)
+        self.winner = player if won?
+      else
+        self.winner = player if will_win?
+      end
+    end
+
+    def over?
+      !!winner
+    end
+
+    def simulate
+      play_turn until over?
+    end
+
+  private
+
+    def init_turn
+      @player = players.at(turn % players.size)
+      @player.roll_die
+      @turn += 1
+    end
+
+    def won?
+      player.position.equal?(board.size)
+    end
+
+    def will_win?
+      player.destination_after_last_roll >= board.size
+    end
+
+    def winner=(player)
+      @winner = player
+      puts "Game over! #{winner} wins in #{winner.turns} turns. Congratulations!"
+    end
+  end
+end

data/lib/snakes_and_ladders/grid.rb

@@ -0,0 +1,55 @@
+module SnakesAndLadders
+  class Grid
+    attr_reader :size, :tile_mappings, :default_tile
+
+    CLASSIC_BOARD_MAPPINGS = [
+      { class: :Portal, location:  1, destination:  38 },
+      { class: :Portal, location:  4, destination:  14 },
+      { class: :Portal, location:  9, destination:  31 },
+      { class: :Portal, location: 16, destination:   6 },
+      { class: :Portal, location: 28, destination:  84 },
+      { class: :Portal, location: 36, destination:  44 },
+      { class: :Portal, location: 40, destination:  42 },
+      { class: :Portal, location: 47, destination:  26 },
+      { class: :Portal, location: 49, destination:  11 },
+      { class: :Portal, location: 51, destination:  67 },
+      { class: :Portal, location: 56, destination:  53 },
+      { class: :Portal, location: 62, destination:  19 },
+      { class: :Portal, location: 64, destination:  60 },
+      { class: :Portal, location: 71, destination:  81 },
+      { class: :Portal, location: 80, destination: 100 },
+      { class: :Portal, location: 87, destination:  24 },
+      { class: :Portal, location: 93, destination:  73 },
+      { class: :Portal, location: 95, destination:  75 },
+      { class: :Portal, location: 98, destination:  78 },
+    ]
+
+    def self.classic
+      mappings = Marshal.load(Marshal.dump(CLASSIC_BOARD_MAPPINGS))
+      new(size: 100, tile_mappings: mappings).build
+    end
+
+    def initialize(size:, tile_mappings: [], default_tile: :Cell)
+      @size = size
+      @tile_mappings = tile_mappings
+      @default_tile = default_tile
+
+      raise ArgumentError, "Board size must be equal to or greater than its tiles." if size < tile_mappings.size
+    end
+
+    def build
+      (1..size).each_with_object({}) { |index, grid| grid[index] = tile_at(index) }
+    end
+
+  private
+
+    def tile_at(index)
+      if mapping = tile_mappings.detect { |tile_map| tile_map[:location].equal?(index) }
+        klass = mapping.delete(:class)
+        SnakesAndLadders.const_get(klass).new(mapping)
+      else
+        SnakesAndLadders.const_get(default_tile).new(location: index)
+      end
+    end
+  end
+end

data/lib/snakes_and_ladders/player.rb

@@ -0,0 +1,34 @@
+module SnakesAndLadders
+  class Player
+    attr_reader :name, :color, :die_rolls
+
+    attr_accessor :position
+
+    def initialize(name:, color:, position: 0, die_rolls: [])
+      @name = name
+      @color = color
+      @position = position
+      @die_rolls = die_rolls
+    end
+
+    def to_s
+      name
+    end
+
+    def roll_die
+      die_rolls.push(rand 1..6).last
+    end
+
+    def turns
+      die_rolls.size
+    end
+
+    def last_roll
+      die_rolls.last
+    end
+
+    def destination_after_last_roll
+      position + last_roll
+    end
+  end
+end

data/lib/snakes_and_ladders/portal.rb

@@ -0,0 +1,21 @@
+module SnakesAndLadders
+  class Portal < Cell
+    attr_reader :destination
+
+    def initialize(location:, destination:)
+      @destination = destination
+      super(location: location)
+
+      raise ArgumentError, "Location and destination can not be equal" if location.equal?(destination)
+    end
+
+    def enter(player, board)
+      puts "#{player} moves to square #{location} and takes a #{type}!"
+      board.move(player, location, destination)
+    end
+
+    def type
+      location > destination ? :snake : :ladder
+    end
+  end
+end

data/lib/snakes_and_ladders/version.rb

@@ -0,0 +1,3 @@
+module SnakesAndLadders
+  VERSION = "1.0.0"
+end

data/lib/snakes_and_ladders.rb

@@ -0,0 +1,22 @@
+require "snakes_and_ladders/game"
+require "snakes_and_ladders/board"
+require "snakes_and_ladders/grid"
+require "snakes_and_ladders/cell"
+require "snakes_and_ladders/portal"
+require "snakes_and_ladders/player"
+require "snakes_and_ladders/version"
+
+begin
+  require "pry"
+rescue LoadError
+end
+
+module SnakesAndLadders
+  def self.classic(players)
+    SnakesAndLadders::Game.new(board: SnakesAndLadders::Board.new, players: players)
+  end
+
+  def self.new_player(name:, color:)
+    SnakesAndLadders::Player.new(name: name, color: color)
+  end
+end

data/snakes_and_ladders.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'snakes_and_ladders/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "snakes_and_ladders"
+  spec.version       = SnakesAndLadders::VERSION
+  spec.authors       = ["Mohamad El-Husseini"]
+  spec.email         = ["husseini.mel@gmail.com"]
+  spec.description   = %q{A Ruby implementation of Snakes and Ladders (Chutes and Ladders) board game.}
+  spec.summary       = %q{This is an object oriented Ruby implementation of the classic Snakes and Ladders (Chutes and Ladders) board game.}
+  spec.homepage      = "https://github.com/abitdodgy/snakes_and_ladders"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files`.split($/)
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.3"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "pry"
+end

data/spec/snakes_and_ladders/board_spec.rb

@@ -0,0 +1,74 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe SnakesAndLadders::Board do
+    let(:luigi) { double(:player) }
+
+    let(:first_cell) { double(:cell) }
+    let(:second_cell) { double(:cell) }
+
+    let(:grid) { { 3 => first_cell, 6 => second_cell } }
+
+    let(:board) { Board.new(grid: grid) }
+
+    describe "#initialize" do
+      it "defaults to classic grid" do
+        expect { Board.new }.not_to raise_error
+      end
+
+      it "sets grid" do
+        board = Board.new(grid: "any")
+        expect(board.grid).to eq "any"
+      end
+    end
+
+    describe "#grid" do
+      it "returns the grid" do
+        expect(board.grid).to eq grid
+      end
+    end
+
+    describe "#size" do
+      it "returns grid size" do
+        expect(board.size).to eq 2
+      end
+    end
+
+    describe "#get_cell" do
+      it "returns object at index" do
+        expect(board.get_cell(3)).to eq first_cell
+      end
+
+      it "returns nil if there is no object at index" do
+        expect(board.get_cell(4)).to be_nil
+      end
+    end
+
+    describe "#move" do
+      context "when player is off the board" do
+        it "moves player to destination" do
+          expect(first_cell).to_not receive(:exit)
+          expect(second_cell).to receive(:enter).with luigi, board
+          board.move(luigi, 0, 6)
+        end
+      end
+
+      context "when player is on a cell" do
+        it "moves player between cells" do
+          expect(first_cell).to receive(:exit).with luigi
+          expect(second_cell).to receive(:enter).with luigi, board
+          board.move(luigi, 3, 6)
+        end
+      end
+
+      context "when movement exceeds board size" do
+        it "does not move player and returns false" do
+          expect(second_cell).not_to receive :exit
+          expect(second_cell).not_to receive :enter
+          result = board.move(luigi, 3, 7)
+          expect(result).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/snakes_and_ladders/cell_spec.rb

@@ -0,0 +1,57 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe Cell do
+    let(:cell) { Cell.new(location: 1) }
+
+    describe "#initialize" do
+      it "raises an error without location" do
+        expect { Cell.new }.to raise_error(ArgumentError).with_message("missing keyword: location")
+      end
+
+      it "sets location" do
+        expect(cell.location).to eq 1
+      end
+
+      it "defaults players to empty array" do
+        expect(cell.players).to eq []
+      end
+
+      it "sets players" do
+        cell = Cell.new(location: 1, players: ["Mario"])
+        expect(cell.players).to eq ["Mario"]
+      end
+    end
+
+    describe "#location" do
+      it "returns location" do
+        expect(cell.location).to eq 1
+      end
+    end
+
+    describe "#players" do
+      it "returns an array" do
+        expect(cell.players).to be_an Array
+      end
+    end
+
+    describe "#enter" do
+      let(:mario) { double(:mario) }
+
+      it "updates player position and adds player to players array" do
+        expect(mario).to receive(:position=).with cell.location
+        cell.enter(mario, "Board")
+        expect(cell.players).to include mario
+      end
+    end
+
+    describe "#exit" do
+      let(:cell) { Cell.new(location: 1, players: ["mario"]) }
+
+      it "delete player from players array" do
+        cell.exit("mario")
+        expect(cell.players).not_to include "mario"
+      end
+    end
+  end
+end

data/spec/snakes_and_ladders/game_spec.rb

@@ -0,0 +1,152 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe Game do
+    let(:game) { Game.new(board: "Board") }
+
+    describe "#initialize" do
+      it "raises an error without board" do
+        expect { Game.new }.to raise_error(ArgumentError).with_message("missing keyword: board")
+      end
+
+      it "sets a board" do
+        expect(game.board).to eq "Board"
+      end
+
+      it "defaults players to empty array" do
+        expect(game.players).to eq []
+      end
+
+      it "sets players array" do
+        game = Game.new(board: "Board", players: %w(Mario Luigi))
+        expect(game.players).to eq %w(Mario Luigi)
+      end
+
+      it "defaults turn to 0" do
+        expect(game.turn).to eq 0
+      end
+
+      it "sets turn" do
+        game = Game.new(board: "Board", turn: 5)
+        expect(game.turn).to eq 5
+      end
+    end
+
+    describe "#board" do
+      it "returns game board" do
+        expect(game.board).to eq "Board"
+      end
+    end
+
+    describe "#players" do
+      it "returns an array" do
+        expect(game.players).to be_an Array
+      end
+    end
+
+    describe "#turn" do
+      it "return an integer" do
+        expect(game.turn).to be_an Integer
+      end
+    end
+
+    describe "#play_turn" do
+      let(:mario) { double(:player, roll_die: 3, position: 1, destination_after_last_roll: 4, turns: 2, last_roll: 3) }
+      let(:luigi) { double(:player, roll_die: 0, position: 0, destination_after_last_roll: 0, turns: 0, last_roll: 0) }
+      let(:peach) { double(:player) }
+
+      let(:players) { [mario, luigi, peach] }
+
+      let(:board) { double(:board, size: 10, move: true) }
+      let(:game) { Game.new(board: board, players: players) }
+
+      it "defaults winner to nil" do
+        expect(game.winner).to be_nil
+      end
+
+      it "is not over" do
+        expect(game.over?).to eq false
+      end
+
+      it "cycles player turns" do
+        game.play_turn
+        expect(game.player).to eq mario
+        game.play_turn
+        expect(game.player).to eq luigi
+      end
+
+      it "calls player.roll_die" do
+        expect(mario).to receive(:roll_die)
+        game.play_turn
+      end
+
+      it "increments turn" do
+        game.play_turn
+        expect(game.turn).to eq 1
+      end
+
+      it "calls board.move" do
+        expect(board).to receive(:move).with(mario, 1, 4)
+        game.play_turn
+      end
+    end
+
+    describe "#simulate" do
+      let(:mario) { Player.new(name: "Mario", color: "Red") }
+      let(:luigi) { Player.new(name: "Luigi", color: "Green") }
+
+      let(:game) { Game.new(board: Board.new, players: [mario, luigi]) }
+
+      before { game.simulate }
+
+      it "simulates and entire game" do
+        expect(game.over?).to eq true
+        expect(game.players).to include game.winner
+        expect(game.play_turn).to be_nil
+      end
+    end
+
+    describe "#over?" do
+      # This depends on the position attribute to decide winner.
+      # This tests the "board.move returns true" scenario, so we must assume mario already moved, and his position was updated.
+      # This explains why position and destination_after_last_roll are equal, which happens when the player moves.
+      context "when player lands on last square" do
+        let(:board) { double(:board, size: 10, move: true) }
+        let(:mario) { double(:mario, roll_die: 1, position: 10, destination_after_last_roll: 10, turns: 1, last_roll: 1) }
+        let(:game) { Game.new(board: board, players: [mario]) }
+
+        it "returns true" do
+          game.play_turn
+          expect(game.over?).to be true
+        end
+      end
+
+      # This depends on destination_after_last_roll to decide winner.
+      # This tests the "board.move returns false" scenario. So mario's position does not get updated, and we must decide if his roll
+      # takes him over the winning line, since he can't move off the board.
+      context "when player roll will cause it to exceed last cell" do
+        let(:board) { double(:board, size: 10, move: false) }
+        let(:mario) { double(:mario, roll_die: 3, position: 9, destination_after_last_roll: 12, turns: 1, last_roll: 3) }
+        let(:game) { Game.new(board: board, players: [mario]) }
+
+        it "returns true" do
+          game.play_turn
+          expect(game.over?).to be true
+        end
+      end
+
+      context "when player roll is not sufficient to win" do
+        let(:board) { double(:board, size: 10, move: true) }
+        let(:mario) { double(:mario, roll_die: 1, position: 8, destination_after_last_roll: 9, last_roll: 1) }
+        let(:game) { Game.new(board: board, players: [mario]) }
+
+        before { game.add_player(mario) }
+
+        it "returns false" do
+          game.play_turn
+          expect(game.over?).to be false
+        end
+      end
+    end
+  end
+end

data/spec/snakes_and_ladders/grid_spec.rb

@@ -0,0 +1,108 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe Grid do
+    let(:grid) { Grid.new(size: 10) }
+
+    context "#initialize" do
+      it "raises an error without size" do
+        expect { Grid.new }.to raise_error(ArgumentError).with_message("missing keyword: size")
+      end
+
+      it "raises an error if object mappings are greater than size" do
+        expect { Grid.new(size: 1, tile_mappings: [{ 1 => 1 }, { 2 => 2 }]) }.to raise_error(ArgumentError)
+      end
+
+      it "sets size" do
+        expect(grid.size).to eq 10
+      end
+
+      it "sets tile_mappings" do
+        tile_mappings = [{ princess: "peach" }]
+        grid = Grid.new(size: 10, tile_mappings: tile_mappings)
+        expect(grid.tile_mappings).to eq tile_mappings
+      end
+
+      it "defaults tile_mappings to an empty array" do
+        expect(grid.tile_mappings).to eq Array.new
+      end
+
+      it "sets default_tile" do
+        grid = Grid.new(size: 10, default_tile: :BowserCastle)
+        expect(grid.default_tile).to eq :BowserCastle
+      end
+
+      it "defaults default_tile to Cell" do
+        expect(grid.default_tile).to eq :Cell
+      end
+    end
+
+    describe "#size" do
+      it "returns an integer" do
+        expect(grid.size).to be_an Integer
+      end
+    end
+
+    describe "#tile_mappings" do
+      it "returns an array" do
+        expect(grid.tile_mappings).to be_an Array
+      end
+    end
+
+    describe "#default_tile" do
+      it "returns a symbol" do
+        expect(grid.default_tile).to be_an Symbol
+      end
+    end
+
+    describe "#build" do
+      let :tile_mappings do
+        [
+          { class: :Portal, location: 1, destination: 3 },
+          { class: :Portal, location: 4, destination: 2 },
+        ]
+      end
+
+      it "builds a grid from mappings" do
+        grid = Grid.new(size: 4, tile_mappings: tile_mappings).build
+        expect(grid).to be_a Hash
+
+        expect(grid[1]).to be_a Portal
+        expect(grid[2]).to be_a Cell
+        expect(grid[3]).to be_a Cell
+        expect(grid[4]).to be_a Portal
+
+        expect(grid[1].location).to eq 1
+        expect(grid[2].location).to eq 2
+        expect(grid[3].location).to eq 3
+        expect(grid[4].location).to eq 4
+
+        expect(grid[1].destination).to eq 3
+        expect(grid[4].destination).to eq 2
+      end
+    end
+
+    describe "#build with custom default_tile" do
+      let :tile_mappings do
+        [ { class: :Portal, location: 1, destination: 3 } ]
+      end
+
+      let(:castle) { double(:Castle) }
+
+      it "builds a grid from mappings" do
+        skip "not sure how to test this since we have no custom class"
+        # grid = Grid.new(size: 3, tile_mappings: tile_mappings, default_tile: :Castle).build
+      end
+    end
+
+    describe "CLASSIC_BOARD_MAPPINGS" do
+      it "should define classic board const" do
+        expect(Grid).to have_constant(:CLASSIC_BOARD_MAPPINGS)
+      end
+    end
+
+    describe ".classic" do
+      skip "just a reminder to test this class method"
+    end
+  end
+end

data/spec/snakes_and_ladders/player_spec.rb

@@ -0,0 +1,123 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe Player do
+    let(:player) { Player.new(name: "Mario", color: "Red") }
+
+    describe "#initialize" do
+      it "raises an error without name" do
+        expect { Player.new(color: "Red") }.to raise_error(ArgumentError).with_message("missing keyword: name")
+      end
+
+      it "raises an error without color" do
+        expect { Player.new(name: "Mario") }.to raise_error(ArgumentError).with_message("missing keyword: color")
+      end
+
+      it "sets player name" do
+        expect(player.name).to eq "Mario"
+      end
+
+      it "sets player color" do
+        expect(player.color).to eq "Red"
+      end
+
+      it "defaults die_rolls to an empty array" do
+        expect(player.die_rolls).to eq []
+      end
+
+      it "sets die_rolls" do
+        player = Player.new(name: "Mario", color: "Red", die_rolls: [1,2,3])
+        expect(player.die_rolls).to eq [1,2,3]
+      end
+
+      it "defaults position to 0" do
+        expect(player.position).to eq 0
+      end
+
+      it "sets position" do
+        player = Player.new(name: "Mario", color: "Red", position: 5)
+        expect(player.position).to eq 5
+      end
+    end
+
+    describe "#name" do
+      it "returns player name" do
+        expect(player.name).to eq "Mario"
+      end
+    end
+
+    describe "#color" do
+      it "returns player color" do
+        expect(player.color).to eq "Red"
+      end
+    end
+
+    describe "#position" do
+      it "returns an integer" do
+        expect(player.position).to be_an Integer
+      end
+    end
+
+    describe "#position=" do
+      it "sets position" do
+        player.position = 5
+        expect(player.position).to eq 5
+      end
+    end
+
+    describe "#to_s" do
+      it "returns the name attribute" do
+        expect(player.to_s).to eq "Mario"
+      end
+    end
+
+    describe "#roll_die" do
+      it "returns an integer" do
+        expect(player.roll_die).to be_an Integer
+      end
+
+      it "is greater than 0" do
+        expect(player.roll_die).to be > 0
+      end
+
+      it "is lesser than 7" do
+        expect(player.roll_die).to be < 7
+      end
+
+      it "records die roll" do
+        roll = player.roll_die
+        expect(player.die_rolls).to include roll
+      end
+    end
+
+    describe "#die_rolls" do
+      it "returns an array" do
+        expect(player.die_rolls).to be_an Array
+      end
+    end
+
+    describe "#turns" do
+      before do
+        3.times { player.roll_die }
+      end
+
+      it "returns the number of turns played" do
+        expect(player.turns).to eq 3
+      end
+    end
+
+    describe "#last_roll" do
+      it "returns the last die roll" do
+        roll = player.roll_die
+        expect(player.last_roll).to eq roll
+      end
+    end
+
+    describe "#destination_after_last_roll" do
+      it "returns last roll added to position" do
+        roll = player.roll_die
+        expect(player.destination_after_last_roll).to eq player.position + roll
+      end
+    end
+  end
+end

data/spec/snakes_and_ladders/portal_spec.rb

@@ -0,0 +1,62 @@
+require "spec_helper"
+
+module SnakesAndLadders
+  describe Portal do
+    let(:portal) { Portal.new(location: 3, destination: 5) }
+
+    describe "#initialize" do
+      it "raises an error without location" do
+        expect { Portal.new(destination: 1) }.to raise_error(ArgumentError).with_message("missing keyword: location")
+      end
+
+      it "raises an error without destination" do
+        expect { Portal.new(location: 1) }.to raise_error(ArgumentError).with_message("missing keyword: destination")
+      end
+
+      it "sets destination" do
+        expect(portal.destination).to eq 5
+      end
+
+      it "calls super and sets location" do
+        expect(portal.location).to eq 3
+      end
+
+      it "raises an error when location is equal to destination" do
+        expect { Portal.new(location: 1, destination: 1) }.to raise_error(ArgumentError)
+      end
+    end
+
+    describe "#location" do
+      it "returns location" do
+        expect(portal.location).to eq 3
+      end
+    end
+
+    describe "#destination" do
+      it "returns destination" do
+        expect(portal.destination).to eq 5
+      end
+    end
+
+    describe "#enter" do
+      let(:board) { double(:board) }
+
+      it "moves player to cell corresponding to its destination" do
+        expect(board).to receive(:move).with("Mario", portal.location, portal.destination)
+        portal.enter("Mario", board)
+      end
+    end
+
+    describe "#type" do
+      it "returns snake when destination is less than location" do
+        portal = Portal.new(location: 5, destination: 1)
+        expect(portal.type).to eq(:snake)
+      end
+
+      it "returns ladder when location is less than destination" do
+        portal = Portal.new(location: 1, destination: 5)
+        expect(portal.type).to eq(:ladder)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,82 @@
+require "snakes_and_ladders"
+require "support/matchers"
+require "support/utils"
+
+# This file was generated by the `rspec --init` command. Conventionally, all
+# specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
+# The generated `.rspec` file contains `--require spec_helper` which will cause this
+# file to always be loaded, without a need to explicitly require it in any files.
+#
+# Given that it is always loaded, you are encouraged to keep this file as
+# light-weight as possible. Requiring heavyweight dependencies from this file
+# will add to the boot time of your test suite on EVERY test run, even for an
+# individual file that may not need all of that loaded. Instead, make a
+# separate helper file that requires this one and then use it only in the specs
+# that actually need it.
+#
+# The `.rspec` file also contains a few flags that are not defaults but that
+# users commonly want.
+#
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+# The settings below are suggested to provide a good initial experience
+# with RSpec, but feel free to customize to your heart's content.
+=begin
+  # These two settings work together to allow you to limit a spec run
+  # to individual examples or groups you care about by tagging them with
+  # `:focus` metadata. When nothing is tagged with `:focus`, all examples
+  # get run.
+  config.filter_run :focus
+  config.run_all_when_everything_filtered = true
+
+  # Many RSpec users commonly either run the entire suite or an individual
+  # file, and it's useful to allow more verbose output when running an
+  # individual spec file.
+  if config.files_to_run.one?
+    # Use the documentation formatter for detailed output,
+    # unless a formatter has already been configured
+    # (e.g. via a command-line flag).
+    config.default_formatter = 'doc'
+  end
+
+  # Print the 10 slowest examples and example groups at the
+  # end of the spec run, to help surface which specs are running
+  # particularly slow.
+  config.profile_examples = 10
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = :random
+
+  # Seed global randomization in this process using the `--seed` CLI option.
+  # Setting this allows you to use `--seed` to deterministically reproduce
+  # test failures related to randomization by passing the same `--seed` value
+  # as the one that triggered the failure.
+  Kernel.srand config.seed
+
+  # rspec-expectations config goes here. You can use an alternate
+  # assertion/expectation library such as wrong or the stdlib/minitest
+  # assertions if you prefer.
+  config.expect_with :rspec do |expectations|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+    expectations.syntax = :expect
+  end
+
+  # rspec-mocks config goes here. You can use an alternate test double
+  # library (such as bogus or mocha) by changing the `mock_with` option here.
+  config.mock_with :rspec do |mocks|
+    # Enable only the newer, non-monkey-patching expect syntax.
+    # For more details, see:
+    #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+    mocks.syntax = :expect
+
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended.
+    mocks.verify_partial_doubles = true
+  end
+=end
+end

data/spec/support/matchers.rb

@@ -0,0 +1,5 @@
+RSpec::Matchers.define :have_constant do |const|
+  match do |owner|
+    owner.const_defined?(const)
+  end
+end

metadata

@@ -0,0 +1,133 @@
+--- !ruby/object:Gem::Specification
+name: snakes_and_ladders
+version: !ruby/object:Gem::Version
+  version: 1.0.0
+platform: ruby
+authors:
+- Mohamad El-Husseini
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-11-30 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby implementation of Snakes and Ladders (Chutes and Ladders) board
+  game.
+email:
+- husseini.mel@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/snakes_and_ladders.rb
+- lib/snakes_and_ladders/board.rb
+- lib/snakes_and_ladders/cell.rb
+- lib/snakes_and_ladders/game.rb
+- lib/snakes_and_ladders/grid.rb
+- lib/snakes_and_ladders/player.rb
+- lib/snakes_and_ladders/portal.rb
+- lib/snakes_and_ladders/version.rb
+- snakes_and_ladders.gemspec
+- spec/snakes_and_ladders/board_spec.rb
+- spec/snakes_and_ladders/cell_spec.rb
+- spec/snakes_and_ladders/game_spec.rb
+- spec/snakes_and_ladders/grid_spec.rb
+- spec/snakes_and_ladders/player_spec.rb
+- spec/snakes_and_ladders/portal_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers.rb
+homepage: https://github.com/abitdodgy/snakes_and_ladders
+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.2.2
+signing_key: 
+specification_version: 4
+summary: This is an object oriented Ruby implementation of the classic Snakes and
+  Ladders (Chutes and Ladders) board game.
+test_files:
+- spec/snakes_and_ladders/board_spec.rb
+- spec/snakes_and_ladders/cell_spec.rb
+- spec/snakes_and_ladders/game_spec.rb
+- spec/snakes_and_ladders/grid_spec.rb
+- spec/snakes_and_ladders/player_spec.rb
+- spec/snakes_and_ladders/portal_spec.rb
+- spec/spec_helper.rb
+- spec/support/matchers.rb