minesweeper 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b10193144ceaeb6995ac3a3a4c747953ac4cc346
+  data.tar.gz: 28a61a483e56e28d921f29a8e6b46b47c1783e7b
+SHA512:
+  metadata.gz: 635519e896eba1fe969dcc1c525a39c8a970ed2dcae841c4936a1e05d5e8495f2ae7354adf48db25fb8806e280c7400b62de89bd7200347354625b4c72e33ffe
+  data.tar.gz: 84589c0690f06746c87c49276a9b03aeb59f64c2c787531dbc180e818b9b7b0e935dfcc3be0268d55812a2fb3785536d45e25b61ee531f8c04a5142b9cee5b27

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+gem 'rspec'
+gem 'guard-rspec', require: false

data/Guardfile

@@ -0,0 +1,77 @@
+# A sample Guardfile
+# More info at https://github.com/guard/guard#readme
+
+## Uncomment and set this to only include directories you want to watch
+# directories %w(app lib config test spec feature)
+
+## Uncomment to clear the screen before every task
+# clearing :on
+
+## Guard internally checks for changes in the Guardfile and exits.
+## If you want Guard to automatically start up again, run guard in a
+## shell loop, e.g.:
+##
+##  $ while bundle exec guard; do echo "Restarting Guard..."; done
+##
+## Note: if you are using the `directories` clause above and you are not
+## watching the project directory ('.'), the you will want to move the Guardfile
+## to a watched dir and symlink it back, e.g.
+#
+#  $ mkdir config
+#  $ mv Guardfile config/
+#  $ ln -s config/Guardfile .
+#
+# and, you'll have to watch "config/Guardfile" instead of "Guardfile"
+
+# Note: The cmd option is now required due to the increasing number of ways
+#       rspec may be run, below are examples of the most common uses.
+#  * bundler: 'bundle exec rspec'
+#  * bundler binstubs: 'bin/rspec'
+#  * spring: 'bin/rspec' (This will use spring if running and you have
+#                          installed the spring binstubs per the docs)
+#  * zeus: 'zeus rspec' (requires the server to be started separately)
+#  * 'just' rspec: 'rspec'
+
+guard :rspec, cmd: "bundle exec rspec" do
+  require "guard/rspec/dsl"
+  dsl = Guard::RSpec::Dsl.new(self)
+
+  # Feel free to open issues for suggestions and improvements
+
+  # RSpec files
+  rspec = dsl.rspec
+  watch(rspec.spec_helper) { rspec.spec_dir }
+  watch(rspec.spec_support) { rspec.spec_dir }
+  watch(rspec.spec_files)
+
+  # Ruby files
+  ruby = dsl.ruby
+  dsl.watch_spec_files_for(ruby.lib_files)
+
+  # Rails files
+  rails = dsl.rails(view_extensions: %w(erb haml slim))
+  dsl.watch_spec_files_for(rails.app_files)
+  dsl.watch_spec_files_for(rails.views)
+
+  watch(rails.controllers) do |m|
+    [
+      rspec.spec.("routing/#{m[1]}_routing"),
+      rspec.spec.("controllers/#{m[1]}_controller"),
+      rspec.spec.("acceptance/#{m[1]}")
+    ]
+  end
+
+  # Rails config changes
+  watch(rails.spec_helper)     { rspec.spec_dir }
+  watch(rails.routes)          { "#{rspec.spec_dir}/routing" }
+  watch(rails.app_controller)  { "#{rspec.spec_dir}/controllers" }
+
+  # Capybara features specs
+  watch(rails.view_dirs)     { |m| rspec.spec.("features/#{m[1]}") }
+
+  # Turnip features and steps
+  watch(%r{^spec/acceptance/(.+)\.feature$})
+  watch(%r{^spec/acceptance/steps/(.+)_steps\.rb$}) do |m|
+    Dir[File.join("**/#{m[1]}.feature")][0] || "spec/acceptance"
+  end
+end

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Michael Alexander
+
+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,55 @@
+Minesweeper TDD Solution
+========================
+
+If you got even most of this project done, you can consider yourself *far* beyond a beginner in Ruby. You're TDDing like the pros, and learning to decompose your methods. Most of all, what you should have learned from this is that smaller and more isolated methods are easier to test, and it's much easier to set up an example than to try to test by absolute logical necessity.
+
+##Points of Interest
+
+- the game loop itself is hard to test beyond expecting messages to be sent to certain objects
+    + make sure to stub out victory conditions so your test doesn't get caught in an infinite loop
+- the board is where the meat of the logic is, and that's where unit testing is most effective
+- to test methods like counting adjacent mines, cheat
+    + use a `before` clause to set mines exactly where you want them
+    + then run your `#num_adjacent_mines` method
+- testing automated mine clearing is hard. don't look for the perfect algorithm here
+    + instead, see if a mine with zero others around it also clears off the 8 mines surrounding it
+- remember that the `equal` method and the `eq` method in Rspec are not the same
+    + if something `equal`s `true`, then it literally IS that object
+    + if it `eq`s `true`, that's normal Ruby Boolean truthiness
+    + `equal` is VERY useful to make sure boolean methods actually work!
+-_Bonus:_ when working with 2D arrays, remember you can always use the `#flatten` method to get at the elements inside.
+    - this comes in really handy when you want to compare two 2D arrays for equality or set all their elements equal
+    - `@board.grid.flatten.each {|s| s.mine = false }` is a one-liner to remove every mine from the board, as another example
+
+
+## A bonus
+
+You can iteratively generate expectations, even stack them. It's not often the right way to go, but every once in a while it's perfect.
+
+ See here:
+
+```code-rspec
+
+context 'if the space has zero mines nearby' do
+# ...other stuff
+
+    it 'should uncover all adjacent mines' do
+
+      subject.mark_clear(3,3)
+
+      # whoa! you can iterate expectations!
+      # this way, the test fails if any one of these 
+      # *NINE* expect clauses fail
+      # which is to say, if any adjacent square remains hidden
+
+      2.upto(4) do |x|
+        2.upto(4) do |y|
+          expect(subject[x][y].visible).to equal true
+        end
+      end
+
+    end
+end
+```
+
+*NOTE: This solution repo is copyrighted material for your private use only and not to be shared outside of Viking Code School.*

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+

data/lib/minesweeper/version.rb

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

data/lib/minesweeper.rb

@@ -0,0 +1,278 @@
+require 'minesweeper/version.rb'
+
+class Board
+  attr_reader :grid, :size
+  attr_accessor :flags_remaining
+
+  def initialize(size = 10)
+    raise "size out of range!" unless size.between?(8, 25)
+    @size = size
+    @grid = Array.new(size){ Array.new(size){ Space.new } }
+
+    place_mines
+    count_nearby_mines
+
+    #must be after mine placement
+    @flags_remaining = mine_count
+  end
+
+  # this took lots of refactoring!!!
+  def mine_count
+    grid.flatten.count { |space| space.mine }
+  end
+
+  def render
+    (self.size-1).downto(0) do |y|
+      print "#{y}|"
+      (0).upto(self.size-1) do |x|
+        render_cell(x, y)
+        print " "
+      end
+      puts "|\n"
+    end
+
+    print "  "
+    print "--" * size
+    puts "\n"
+    print " "
+    0.upto(self.size-1) {|x| print " #{x}"}
+    puts "\n"
+    puts "Flags remaining: #{flags_remaining}\n"
+    nil
+  end
+
+  #show everything if you lose
+  def endgame_render
+    self.grid.flatten.each {|space| space.visible = true }
+    render
+  end
+
+  # rather than just calling board.grid[row][col]
+  # this passes the grid directly through
+  # so you can call board[row][col]
+
+  def [](index)
+    self.grid[index]
+  end
+
+
+
+  def place_flag( x, y )
+    return false if flags_remaining <= 0
+    return false if self[x][y].visible
+
+    self[x][y].flagged = true
+    self.flags_remaining -= 1
+    true
+  end
+
+  def mark_clear( x, y )
+    return false if self[x][y].visible
+    self[x][y].visible = true
+
+    if self[x][y].zero_nearby?
+
+      #mark all of them as well
+      adjacent_spaces(x, y).each do |coords|
+        adj_x, adj_y = coords[0], coords[1]
+        mark_clear(adj_x, adj_y)
+      end
+
+    end
+
+    true
+  end
+
+  # all non-mine spaces are visible
+  def victory?
+    self.grid.flatten.select {|space| !space.mine }.
+                      all? {|space| space.visible }
+  end
+
+
+  def game_lost?
+    touched_a_mine? 
+  end
+
+  def num_adjacent_mines(x, y)
+    mine_count = 0
+
+    adjacent_spaces(x, y).each do |coords|
+      adj_x, adj_y = coords[0], coords[1]
+      mine_count += 1 if self.grid[adj_x][adj_y].mine
+    end
+
+    mine_count
+  end
+
+
+  private
+
+  def render_cell(x, y)
+    cell = self.grid[x][y]
+
+    if !cell.visible && cell.flagged
+      print "F"
+    elsif !cell.visible
+      print "_"
+    elsif cell.mine
+      print "M"
+    else
+      print cell.nearby_mines
+    end
+  end
+
+
+  # oops. you found a mine
+  def touched_a_mine?
+    self.grid.flatten.any?{ |cell| cell.visible && cell.mine }
+  end
+  
+
+  # used to decide whether recursive clearing
+  # is possible on a space (No mine, not visible yet)
+  # AND has 0 nearby mines
+  def can_clear? ( x, y )
+    !self[x][y].visible && 
+    !self[x][y].mine && 
+    self[x][y].nearby_mines == 0
+  end
+
+  def count_nearby_mines
+    0.upto(self.grid.size - 1) do |x|
+      0.upto(self.grid.size - 1) do |y|
+        self.grid[x][y].nearby_mines = num_adjacent_mines(x, y)
+      end
+    end
+  end
+
+  def adjacent_spaces(x,y)
+
+    coords = []
+
+    (x - 1).upto(x + 1) do |adj_x|
+      (y - 1).upto(y + 1) do |adj_y|
+
+        # don't count yourself
+        next if ((x == adj_x) && (y == adj_y))
+
+        #if coords are within the bounds of the grid
+        if (adj_x >= 0 && adj_y >= 0) && (adj_x < self.size && adj_y < self.size)
+
+          #add them to the list of adjacent coordinates
+          coords.push([adj_x, adj_y])
+        end
+      end
+    end
+
+    coords
+  end
+
+
+  def place_mines
+
+    mines_to_place = [ (self.size - 7)**2, 100].min
+
+    while mines_to_place > 0
+      x, y = rand(self.size), rand(self.size)
+
+      unless self.grid[x][y].mine
+        self.grid[x][y].mine = true
+        mines_to_place -= 1
+      end
+
+    end
+
+  end
+
+  
+end
+
+class Space
+  attr_accessor :visible, :flagged, :mine, :nearby_mines
+
+  def initialize
+    @visible = false
+    @flagged = false
+    @mine = false
+    @nearby_mines = nil
+  end
+
+  def clear?
+    visible && !mine
+  end
+
+  def zero_nearby?
+    clear? && self.nearby_mines == 0
+  end
+end
+
+
+
+class Player
+  def initialize(board)
+    @board = board
+  end
+
+  def take_turn
+
+    until make_move do
+      puts "That didn't work. Try again."
+    end
+  end
+
+  private
+
+  def make_move
+    puts "Mark a square as (C)lear\n or (F)lag it as a mine?"
+    print "> "
+    choice = gets.chomp.upcase
+
+    print "Choose coordinates in the form of x, y: "
+    x, y = gets.chomp.split(',').map{|c| c.to_i }
+
+    if choice == "F"
+      @board.place_flag(x, y)
+    else
+      @board.mark_clear(x, y)
+    end
+  end
+
+end
+
+
+class Game
+
+  attr_reader :player, :board
+
+  def initialize
+    @board = Board.new
+    @player = Player.new(@board)
+  end
+
+  def play
+
+    loop do
+      board.render
+      player.take_turn
+      break if game_over?
+    end
+
+    endgame
+  end
+
+  private
+
+  def game_over?
+    board.victory? || board.game_lost?
+  end
+
+  def endgame
+    board.endgame_render
+    puts "Oh no! You touched a mine!" if board.game_lost?
+    puts "Congratulations! You won!" if board.victory?
+    puts "Thanks for playing!"
+  end
+end
+
+

data/minesweeper.gemspec

@@ -0,0 +1,25 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'minesweeper/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "minesweeper"
+  spec.version       = Minesweeper::VERSION
+  spec.authors       = ["Michael Alexander"]
+  spec.email         = ["alexandermw@gmail.com"]
+  spec.summary       = %q{Minesweeper on the command line in Ruby, TDD-ed.}
+  spec.description   = %q{Tests in Rspec}
+  spec.homepage      = ""
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  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.7"
+  spec.add_development_dependency "rake", "~> 10.0"  
+  spec.add_development_dependency "rspec", "~> 3.1.0"
+  spec.add_development_dependency "guard", "~> 4.5.0"
+end

data/spec/minesweeper_spec.rb

@@ -0,0 +1,253 @@
+require 'minesweeper'
+require 'pry'
+
+describe Game do 
+  it 'should have a Player' do
+    expect(subject.player).to be_a Player
+  end
+
+  it 'should have a Board' do
+    expect(subject.board).to be_a Board
+  end
+
+  describe '#play' do
+    it 'should call player#take_turn' do
+      #necessary to avoid infinite loop
+      allow(subject.board).to receive(:victory?).and_return(true)
+      allow(subject.player).to receive(:take_turn)
+
+      expect(subject.player).to receive(:take_turn)
+      subject.play
+    end
+    it 'should call board#render' do
+      #avoid infinite loop
+      allow(subject.board).to receive(:victory?).and_return(true)
+      allow(subject.player).to receive(:take_turn)
+
+      expect(subject.board).to receive(:render).at_least(1).times
+      subject.play
+    end
+  end
+end
+
+describe Player do
+
+  #left as an exercise for the student
+
+end
+
+describe Board do
+
+  describe "#initialize" do
+
+    context 'with default options' do
+      it "should create a 10x10 array by default" do
+        expect(subject.size).to eq(10)
+      end
+
+      it "should have 9 mines by default" do
+        expect(subject.mine_count).to eq(9)
+      end
+
+      it 'should count adjacent mines up-front' do
+        expect( subject.grid.flatten.all? { |space| space.nearby_mines. is_a? Integer } ).to eq true
+      end
+
+    end
+
+
+    it 'should be an array' do
+      expect(subject.grid).to be_a Array
+    end
+
+    it 'should be an array of arrays' do
+      expect(subject.grid[0]).to be_a Array
+    end
+
+    # careful, this test has false positive if size is 0 
+    it 'should be composed of spaces' do
+      expect(subject.grid.flatten.all? { |space| space.is_a? Space }).to eq true
+    end
+
+    it 'should have all Spaces be invisible at first' do
+      expect(subject.grid.flatten.all? {|s| !s.visible } ).to eq true
+    end
+
+    it 'should always be square' do
+      expect(subject.grid.size).to eq subject.grid[0].size
+    end
+
+    it 'can take a size up to 25' do
+      expect{Board.new(25)}.not_to raise_error
+    end
+
+    it 'creates 9 mines for a 10x10' do
+      expect(subject.mine_count).to eq 9
+    end
+
+    it 'creates 100 mines for a 25 x 25' do
+      expect( Board.new(25).mine_count ).to eq 100
+    end
+
+    it 'raises an error if inputs are not positive integers' do
+      expect{Board.new(-4)}.to raise_error
+    end
+
+    it 'raises an error if size are greater than 25' do
+      expect{Board.new(26)}.to raise_error
+    end
+
+    it 'should start with as many flags remaining as mines' do
+      expect(subject.flags_remaining).to eq(subject.mine_count)
+    end
+
+  end
+
+  describe '#render' do
+
+  end
+
+  describe '#place_flag' do
+    it 'should only be allowed if flags remain' do
+      allow(subject).to receive(:flags_remaining).and_return(0)
+      expect(subject.place_flag(0,0)).to eq(false)
+    end
+    it 'should only be valid on uncleared spaces' do
+      subject[0][0].mine = false
+      subject[0][0].visible = true
+
+      expect(subject.place_flag(0,0)).to eq(false)
+    end
+    it 'should decrement the flag counter by 1 if successful' do
+      flag_count = subject.flags_remaining
+      subject.place_flag(0,0)
+      expect(subject.flags_remaining).to eq (flag_count - 1)
+    end
+    it 'should change a space to appear flagged' do
+      subject.place_flag(0,0)
+      expect(subject[0][0].flagged).to eq true
+    end
+  end
+
+  describe '#mark_clear' do
+
+    it 'should change the space to visible' do
+      subject.mark_clear(0,0)
+      expect(subject[0][0].visible).to equal true
+    end
+
+    context 'if the space chosen is clear' do
+
+      #set up safe and unsafe spots
+      before(:each) do
+        subject[0][0].mine = false
+        subject[0][1].mine = false
+        subject[1][0].mine = false
+        subject[1][1].mine = true
+      end
+
+      it 'should not trigger a loss' do
+        expect(subject.game_lost?).to equal(false)
+      end
+    end
+
+    context 'if the space chosen has a mine' do
+      before(:each) do
+        subject[0][0].mine = true
+      end
+
+      it 'should trigger a loss' do
+        subject.mark_clear(0,0)
+        expect(subject.game_lost?).to equal true
+      end
+    end
+
+    context 'if the space has zero mines nearby' do
+
+      before(:each) do
+        subject.grid.flatten.each {|s| s.mine = false }
+        subject[3][3].nearby_mines = 0
+      end
+
+
+      # in a perfect world, we also want a test that checks
+      # if it keeps going forever. since that's a lot to mock out
+      # this test will stay around
+      it 'should uncover all adjacent mines' do
+
+        subject.mark_clear(3,3)
+
+        # whoa! you can iterate expectations!
+        # this way, the test fails if any one of these 
+        # *NINE* expect clauses fail
+        2.upto(4) do |x|
+          2.upto(4) do |y|
+            expect(subject[x][y].visible).to equal true
+          end
+        end
+
+      end
+
+    end
+  end
+
+  describe '#victory?' do
+    it 'should be true when all non-mine spaces are visible' do
+      subject.grid.flatten.map! {|s| s.visible = true unless s.mine }
+      expect(subject.victory?).to equal true
+    end
+
+    it 'should be false otherwise' do
+      expect(subject.victory?).to equal false
+    end
+  end
+
+  describe '#game_lost?' do
+    it 'should be true as soon as a mine is marked as clear' do
+      subject[0][0].mine = true
+      subject.mark_clear(0,0)
+      expect(subject.game_lost?).to equal true
+    end
+
+    it 'should be false otherwise' do
+      expect(subject.game_lost?).to equal false
+    end
+  end
+
+  describe '#num_adjacent_mines' do
+    let(:single_mine){ Board.new }
+
+    before(:each) do
+      # this test board has a single mine only at 0, 0
+      single_mine.grid.flatten.each {|cell| cell.mine = false }
+      single_mine.grid[0][0].mine = true
+    end
+
+    it 'returns 0 when there are no mines next to a square' do
+      expect(single_mine.num_adjacent_mines(9,9)).to eq 0
+    end
+
+    it 'returns the number of mines next to a square' do
+      expect(single_mine.num_adjacent_mines(1,1)).to eq 1
+    end
+
+  end
+
+end
+
+describe Space do
+
+  describe '#initialize' do
+    it 'should start invisible' do
+      expect(subject.visible).to eq(false)
+    end
+
+    it 'should default to no mine' do
+      expect(subject.mine).to eq(false)
+    end
+
+    it 'should default to not flagged' do
+      expect(subject.flagged).to eq(false)
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,89 @@
+# 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, consider making
+# a separate helper file that requires the additional dependencies and performs
+# the additional setup, and require it from the spec files 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|
+  # 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|
+    # This option will default to `true` in RSpec 4. It makes the `description`
+    # and `failure_message` of custom matchers include text for helper methods
+    # defined using `chain`, e.g.:
+    # be_bigger_than(2).and_smaller_than(4).description
+    #   # => "be bigger than 2 and smaller than 4"
+    # ...rather than:
+    #   # => "be bigger than 2"
+    expectations.include_chain_clauses_in_custom_matcher_descriptions = true
+  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|
+    # Prevents you from mocking or stubbing a method that does not exist on
+    # a real object. This is generally recommended, and will default to
+    # `true` in RSpec 4.
+    mocks.verify_partial_doubles = true
+  end
+
+# 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
+
+  # Limits the available syntax to the non-monkey patched syntax that is recommended.
+  # For more details, see:
+  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
+  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
+  config.disable_monkey_patching!
+
+  # This setting enables warnings. It's recommended, but in some cases may
+  # be too noisy due to issues in dependencies.
+  config.warnings = 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
+=end
+end

data/test.rb

@@ -0,0 +1,11 @@
+def count_between(arr, low, high)
+  counter = 0
+
+  arr.each do |element|
+    if (element >= low && element <= high)
+      counter++
+    end
+  end
+  
+  return counter
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: minesweeper
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Michael Alexander
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-01-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 3.1.0
+- !ruby/object:Gem::Dependency
+  name: guard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.5.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 4.5.0
+description: Tests in Rspec
+email:
+- alexandermw@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".DS_Store"
+- ".gitignore"
+- Gemfile
+- Guardfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- lib/.DS_Store
+- lib/minesweeper.rb
+- lib/minesweeper/.DS_Store
+- lib/minesweeper/version.rb
+- minesweeper.gemspec
+- spec/.DS_Store
+- spec/minesweeper_spec.rb
+- spec/spec_helper.rb
+- test.rb
+homepage: ''
+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.4.2
+signing_key: 
+specification_version: 4
+summary: Minesweeper on the command line in Ruby, TDD-ed.
+test_files:
+- spec/.DS_Store
+- spec/minesweeper_spec.rb
+- spec/spec_helper.rb
+has_rdoc: