SOLO CHALLENGE: Create A Boggle Board Class

phase0_boggle_class.rb

# 1) Instantiate a new board object

class BoggleBoard
  def initialize(board)
    @board = board
  end
  def create_word(*coordinates)
    coordinates.map { |coordinates| @board[coordinates.first][coordinates.last]}.join
  end
  def get_row(row)
    @board[row].join
  end
  def get_col(col)
    @board.map { |i| i[col] }.join
  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)

# 2) Implement your methods

p boggle_board.create_word([1,2],[1,1],[2,1],[3,2]) #=> creates "dock"

p boggle_board.get_row(0)
p boggle_board.get_row(1)
p boggle_board.get_row(2)
p boggle_board.get_row(3) #=> creates "take"

p boggle_board.get_col(0)
p boggle_board.get_col(1)
p boggle_board.get_col(2)
p boggle_board.get_col(3) #=> creates "etre," which is a French word. Sorta counts?

# 3) Access a coordinate

p boggle_board.create_word([3,2]) == "k"
p boggle_board.create_word([2,1]) == "c"
p boggle_board.create_word([3,0]) == "t"

# 4) Bonus: Create a #get_diagonal method
# I'm still working on the get_diagonal method, it's driving me a bit nuts. Draft below:
# Reminder to self: **do not run this, it's an infinite loop**

  def get_diagonal(coord1,coord2)
    output = []
    coord11 = coord1.first
    coord12 = coord1.last
    coord21 = coord2.first
    coord22 = coord2.last

    if (coord1.first - coord2.first).abs == (coord1.last - coord2.last).abs
      p @board[coord11][coord12]
      until coord11 == coord21
        output << @board[coord11][coord12]
        coord11 =+ 1
        coord12 =+ 1
        p coord11
      end
      p output
    else
      raise ArgumentError.new("not a diagonal") 
    end
  end
end

p boggle_board.get_diagonal([0,0],[3,3])
p boggle_board.get_diagonal([0,1],[2,3])
p boggle_board.get_diagonal([0,0],[2,3])

# The day after the gist was due Johnathan Weisner gave me some tips to improve my code (like pointing out I'd written 
# my += backwards) and suggested some good driver code. This is what I ended up with:

class BoggleBoard
  def initialize(board)
    @board = board
  end
  def create_word(*coordinates)
    coordinates.map { |coordinates| @board[coordinates.first][coordinates.last]}.join
  end
  def get_row(row)
    @board[row].join
  end
  def get_col(col)
    @board.map { |i| i[col] }.join
  end
  def get_diagonal(first,last)
    output = []

    if (first[0] - last[0]).abs == (first[1] - last[1]).abs
      output << @board[first[0]][first[1]]
      if first[0] < last[0] && first[1] < last[1]
        until first[0] == last[0]
          first[0] += 1
          first[1] += 1
          output << @board[first[0]][first[1]]
        end
      elsif first[0] > last[0] && first[1] < last[1]
        until first[0] == last[0]
          first[0] -= 1
          first[1] += 1
          output << @board[first[0]][first[1]]
        end
      elsif first[0] > last[0] && first[1] > last[1]
        until first[0] == last[0]
          first[0] -= 1
          first[1] -= 1
          output << @board[first[0]][first[1]]
        end
      else
        until first[0] == last[0]
          first[0] += 1
          first[1] -= 1
          output << @board[first[0]][first[1]]
        end
      end
      output.join
    else
      raise ArgumentError.new("not a diagonal") 
    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)

puts boggle_board.get_diagonal([0,0],[3,3]) # => bole, [0,0],[3,3] first[0] < last[0] && first[1] < last[1]
puts boggle_board.get_diagonal([3,0],[0,3]) # => tcde, [3,0],[0,3] first[0] > last[0] && first[1] < last[1]
puts boggle_board.get_diagonal([2,3],[0,1]) # => rdr, [2,3],[0,1] first[0] > last[0] && first[1] > last[1]
puts boggle_board.get_diagonal([0,2],[2,0]) # => aoe, [0,2],[2,0] first[0] < last[0] && first[1] > last[1]
puts boggle_board.get_diagonal([1,0],[3,2]) # => ick, [1,0],[3,2] first[0] < last[0] && first[1] < last[1]

# puts boggle_board.get_diagonal([0,0],[2,3]) #=> should raise "not a diagonal" error

# 5) Review and Reflect

# I don't understand why I can't seem to make BoggleBoard a subclass of Array like so:
  # class BoggleBoard < Array
# and have it inherit Array's behaviors so that p boggle_board[3][2] would work.