maze.rb

class Maze
  def initialize(maze)
    raise ArgumentError, "Invalid maze." if maze.nil? or maze.empty? or not maze.include?("\n")
    @maze_width = maze.index("\n")
    @maze = maze.gsub("\n", '').split(//) # The maze is represented as an array.
  end

  def solvable?
    path_finder(@maze.index('A'))
  end

  protected

  # Recursively determines if from _here_ we can reach the end of the maze
  # by looking at the adjacent cells (Up, Down, Left and Right). Moreover, cells that have
  # already been visited are tracked so we don't repeat ourselfs.
  #
  #   here:           starting index in the maze
  #   visited_cells:  the indicies that were already visited during the path search.
  def path_finder(here, visited_cells=[])
    return false if out_of_bounds?(here) or visited_cells.include?(here) or @maze[here] == "#"
    return true if @maze[here] == 'B'
    visited_cells << here
    return (path_finder(here-1, visited_cells) or path_finder(here+1, visited_cells) or path_finder(here-@maze_width, visited_cells) or path_finder(here+@maze_width, visited_cells))
  end

  # Determine if it's a valid location in the maze.
  def out_of_bounds?(index)
    return (index >= @maze.length or index < 0) ? true : false
  end
end

test_maze.rb

require 'test/unit'
require 'maze'

MAZE1 = %{#####################################
# #   #     #A        #     #       #
# # # # # # ####### # ### # ####### #
# # #   # #         #     # #       #
# ##### # ################# # #######
#     # #       #   #     # #   #   #
##### ##### ### ### # ### # # # # # #
#   #     #   # #   #  B# # # #   # #
# # ##### ##### # # ### # # ####### #
# #     # #   # # #   # # # #       #
# ### ### # # # # ##### # # # ##### #
#   #       #   #       #     #     #
#####################################}
# Maze 1 should SUCCEED

MAZE2 = %{#####################################
# #       #             #     #     #
# ### ### # ########### ### # ##### #
# #   # #   #   #   #   #   #       #
# # ###A##### # # # # ### ###########
#   #   #     #   # # #   #         #
####### # ### ####### # ### ####### #
#       # #   #       # #       #   #
# ####### # # # ####### # ##### # # #
#       # # # #   #       #   # # # #
# ##### # # ##### ######### # ### # #
#     #   #                 #     #B#
#####################################}
  # Maze 2 should SUCCEED

MAZE3 = %{#####################################
# #   #           #                 #
# ### # ####### # # # ############# #
#   #   #     # #   # #     #     # #
### ##### ### ####### # ##### ### # #
# #       # #  A  #   #       #   # #
# ######### ##### # ####### ### ### #
#               ###       # # # #   #
# ### ### ####### ####### # # # # ###
# # # #   #     #B#   #   # # #   # #
# # # ##### ### # # # # ### # ##### #
#   #         #     #   #           #
#####################################}
# Maze 3 should FAIL

class MazeTest < Test::Unit::TestCase
  def test_good_mazes
    assert Maze.new(MAZE1).solvable?
    assert Maze.new(MAZE2).solvable?
  end

  def test_bad_mazes
    assert_equal false, Maze.new(MAZE3).solvable?
  end

  # def test_maze_steps
  #   assert_equal 44, Maze.new(MAZE1).steps
  #   assert_equal 75, Maze.new(MAZE2).steps
  #   assert_equal 0, Maze.new(MAZE3).steps
  # end

  def test_empty_string
    assert_raise ArgumentError do
      Maze.new('')
    end
  end

  def test_nil_string
    assert_raise ArgumentError do
      Maze.new(nil)
    end
  end

  def test_one_line_maze
    assert_raise ArgumentError do
      Maze.new("AB")
    end
  end

  def test_correct_string
    assert_nothing_raised ArgumentError do
      Maze.new("AB\n")
    end
  end
end