P0 U2 W4 - Challenge 440 - boggle class challenge

0.2.1-boggle_class_from_methods.rb

class BoggleBoard
  def initialize(dice_grid)
  	@dice_grid = dice_grid
  end

  def create_word(*coords)
  	coords.map { |coord| @dice_grid[coord.first][coord.last]}.join("")
  end

  def get_row(row)
  	@dice_grid[row]
  end	
 
  def get_col(col)
    column_array = []
  	4.times { |row| column_array << @dice_grid[row][col] }
  	column_array
  end

  #Plan on coming back to get_diagonal
  def get_diagonal(coord1, coord2)
    coord_collection = []
  	coordx, coordy = coord1.first, coord1.last
  	direction = (coord1.first-coord2.first)/(coord1.last-coord2.last)
  	
  	if (direction).abs == 1
      until coordx == 0 || coordy == 0 #Move points to the beginning of the diagonal.
        coordy -= 1    
        direction = 1? coordx -= 1 : coordx += 1
      end
      coord_collection << @dice_grid[coordx][coordy]

      while coordx < 4 && coordy < 4 #Gather the rest of the points from diagonal
          coordy += 1
          direction == 1? coordx += 1 : coordx -= 1
          coord_collection << @dice_grid[coordx][coordy] if coordx < 4 && coordy < 4 && coordx > -1 && coordy > -1 
      end
      coord_collection
  	else
  		raise ArgumentError.new("Coordinates are not daigaonal.")
  	end
  end
end

dice_grid = [["b", "r", "a", "e"],
             ["i", "o", "d", "t"],
             ["e", "c", "l", "r"],
             ["t", "a", "k", "e"]]

boggle_board = BoggleBoard.new(dice_grid)

#DRIVER CODE:

puts "These should return 3 trues and a false: "
p boggle_board.create_word([0,1]) == "r" # => Returns true
p boggle_board.create_word([2,1]) == "c" # => Returns true
p boggle_board.create_word([3,3]) == "e" # => Returns true
p boggle_board.create_word([2,3]) == "x" # => Returns false

puts "These should return code, rad, rocker, load and dock: "
p boggle_board.create_word([2,1], [1,1], [1,2], [0,3])               # => returns "code"  
p boggle_board.create_word([0,1], [0,2], [1,2])                      # => Returns "rad"
p boggle_board.create_word([0,1], [1,1], [2,1], [3,2], [3,3], [2,3]) # => Returns "rocker"
p boggle_board.create_word([2,2], [1,1], [0,2], [1,2])               # => Returbs "load"
p boggle_board.create_word([1,2], [1,1], [2,1], [3,2])               # => Returbs 

puts "Returns row 1, 2, 3, 4: "
p boggle_board.get_row(0) # => Returns ["b", "r", "a", "e"]
p boggle_board.get_row(1) # => Returns ["i", "o", "d", "t"]
p boggle_board.get_row(2) # => Returns ["e", "c", "l", "r"]
p boggle_board.get_row(3) # => Returns ["t", "a", "k", "e"]

puts "Returns column 1, 2, 3, 4: "
p boggle_board.get_col(0) # => Returns ["b", "i", "e", "t"]
p boggle_board.get_col(1) # => Returns ["r", "o", "c", "a"]
p boggle_board.get_col(2) # => Returns ["a", "d", "l", "k"]
p boggle_board.get_col(3) # => Returns ["e", "t", "r", "e"]

puts "All Rows and Columns returned as strings"
4.times { |element| p boggle_board.get_row(element).join("") }  # => Returns 
4.times { |element| p boggle_board.get_col(element).join("") }  # => Returns 

puts "Return for get diagonal calls: "
p boggle_board.get_diagonal([2,2], [3,3]) # => Returns ["b", "o", "l", "e"]
p boggle_board.get_diagonal([0,0], [3,3]) # => Returns ["b", "o", "l", "e"]
p boggle_board.get_diagonal([2,0], [0,2]) # => Returns ["e", "o", "a"]
p boggle_board.get_diagonal([3,0], [0,3]) # => Returns ["t", "c", "d", "e"]
p boggle_board.get_diagonal([0,1], [2,3]) # => Returns ["r", "d", "r"]
p boggle_board.get_diagonal([3,0], [3,3]) # => Returns error, not diagonal