Why is "box1" undefined after calling "box#{i} = ..."? - ruby

Question

I'm trying to create a tic-tac-toe game. I listed only the code for the relevant class and methods I got so far:
class Box
attr_reader :name, :row, :column
attr_accessor :is_marked, :contents
def initialize(name, row, column, is_marked=false, contents)
#name = name
#row = row
#column = column
#is_marked = is_marked
#contents = contents
end
def self.display_box
print '|#{contents}|'
end
end
#generate box instances
(1..9).each do |i|
if i > 3
col = i % 3
else
col = i
end
box#{i} = Box.new('box#{i}', (i/3).ceil, col, false, '_')
end
board = [[box1, box2, box3], [box4, box5, box6], [box7, box8, box9]]
def display_board
box1.display_box; box2.display_box; box3.display_box; print '\n'
box4.display_box; box5.display_box; box6.display_box; print '\n'
box7.display_box; box8.display_box; box9.display_box; print '\n'
end
display_board
I can't figure out why creating an instance of my class throws an error. The error is:
undefined local variable or method `box1' for <Context:0x000000024df8a8>
(repl):44:in display_board'
(repl):61:in initialize'
I tried running it with and without the 'self' in the display_box method, same error.

Answer 1

The problem is this line.
box#{i} = Box.new('box#{i}', (i/3).ceil, col, false, '_')
It seems like you're trying to create a bunch of variables named box1, box2, ... There might be away way to do that in ruby, but that's not it. You could do it with eval, but you don't want to this. As you can see from the rest of your code, working with a big pile of variables like that is annoying.
Instead, make an Array of boxes.
boxes[i] = Box.new("box#{i}", (i/3).ceil, col, false, '_')
You need to declare boxes = [] before the loop.
Then create your board from that list using ranges.
board = [boxes[1..3], boxes[4..6], boxes[7..9]]
And display_board becomes less repetitive.
def display_board(board)
board.each { |row|
row.each { |box|
box.display_box
}
puts "\n"
}
end
Finally, if you want to interpolate variables in strings you have to use ". For example, in display_box.
def display_box
print "|#{contents}|"
end

Answer 2

This is an error:
box#{i}
You can interpolate into Strings(and regexes), but a variable name is not a
String. A String has quotes around it.
Even if you could interpolate into variable names, you would never do this:
box#{i} = Box.new('box#{i}', (i/3).ceil, col, false, '_')
Instead, you would create an Array and add instances to the Array:
boxes = []
(1..9).each do |i|
if i > 3
col = i % 3
else
col = i
end
boxes << Box.new('box#{i}', (i/3).ceil, col, false, '_')
end
Then the names of your instances are boxes[0], boxes[1], etc.
You also need to know that a def creates a new scope and variables outside the def cannot be seen inside the def. So any box1, box2, etc. variables created outside the def cannot be seen inside the def. What you need to do is pass the boxes Array to the display_board() method, like this:
def display_board(board_boxes)
...
end
display_board(boxes)
Ruby then lines up your method call and the method header like this:
display_board(boxes)
|
V
def display_board(board_boxes)
and the boxes Array gets assigned to a variable called board_boxes:
board_boxes = boxes
Then inside the def, board_boxes will be the Array containing the boxes.
Don't combine lines of code on one line using semi colons. When you use an Array to store your box instances, you can display your boxes like this:
board_boxes.each do |box|
box.display_box
end
If you want to print a newline after every three boxes, you can do this:
count = 1
board_boxes.each do |box|
box.display_box
print "\n" if count%3 == 0
count += 1
end

Answer 3

You get undefined local variable or method `box1' because box1 is not defined.
Apparently, you expected this line to create box1:
box#{i} = ...
but it is really just this:
box
because # starts a comment.
Double-quotes strings allow interpolation, but you can't interpolate variable names like this.
How to solve it?
It is almost always a bad idea to create variables dynamically. If you have a large or a varying number of values, you should store them in a collection - either an Array, a Hash, or a custom one.
The box object
Setting up the boxes is quite complex, because you are passing name, row and column to each box. Does a box really have to know its position within the board? Think about other objects that are part of a larger structure: an array element doesn't know its index (the array does), a character doesn't know its position (the string does) and a hash value doesn't know its key (the hash does).
Let's remove these extra attributes from Box and have it just store its content:
class Box
attr_accessor :content
def initialize
#content = '_'
end
def marked?
content != '_'
end
end
b = Box.new #=> #<Box:0x007fab7a9f58a8 #content="_">
b.content #=> "_"
b.marked? #=> false
b.content = 'X'
b.marked? #=> true
The board object
To create a 3×3 array of boxes, we can write: (I've removed the object ids from the output)
board = Array.new(3) { Array.new(3) { Box.new } }
#=> [[#<Box #content="_">, #<Box #content="_">, #<Box #content="_">],
# [#<Box #content="_">, #<Box #content="_">, #<Box #content="_">],
# [#<Box #content="_">, #<Box #content="_">, #<Box #content="_">]]>
Single boxes can be accessed via: (indices are zero-based)
board[0][0] #=> #<Box #content="_">
But since board is such an important object, I'd write a custom class:
class Board
def initialize
#boxes = Array.new(3) { Array.new(3) { Box.new } }
end
def box(x, y)
#boxes[x][y]
end
end
The class does not expose #boxes, because we don't want the array to be changed. It provides a method Board#box instead that returns the box for the given x and y coordinates.
Formatting
In my opinion neither Box nor Board should contain code that handles formatting, so let's write a small utility class to handle this part:
class BoardFormatter
def draw(board)
template.gsub(/[0-8]/) do |n|
x, y = n.to_i.divmod 3
board.box(x, y).content
end
end
def template
<<-STR
0 | 1 | 2
---+---+---
3 | 4 | 5
---+---+---
6 | 7 | 8
STR
end
end
BoardFormatter#template returns the string for the board. You might not have seen <<- before: it's called a heredoc and creates a multiline string between the given STR delimiters:
formatter = BoardFormatter.new
formatter.template #=> " 0 | 1 | 2\n---+---+---\n 3 | 4 | 5\n---+---+---\n 6 | 7 | 8\n"
BoardFormatter#draw uses String#gsub to replace each digit ([0-8]) with the respective box' content.
divmod is the key here, it returns both, a / b and a % b as an array. And because we're using zero-based indices, these are just the box coordinates for the nth box:
0.divmod(3) #=> [0, 0]
1.divmod(3) #=> [0, 1]
2.divmod(3) #=> [0, 2]
3.divmod(3) #=> [1, 0]
4.divmod(3) #=> [1, 1]
5.divmod(3) #=> [1, 2]
6.divmod(3) #=> [2, 0]
7.divmod(3) #=> [2, 1]
8.divmod(3) #=> [2, 2]
Complete example:
board = Board.new
board.box(0, 2).content = 'X'
board.box(0, 0).content = 'O'
board.box(2, 0).content = 'X'
board.box(1, 1).content = 'O'
formatter = BoardFormatter.new
puts formatter.draw(board)
Output:
O | _ | X
---+---+---
_ | O | _
---+---+---
X | _ | _
One-based indices
The players should probably enter one-based indices when playing your game. This conversion should be handled when processing the user input. Within your core code, you should always use zero-based indices, just like Ruby.

Answer 4

As other users mentioned you can create an array to hold the instances of Box.
If you are dead set on using variables you can use instance_variable_set although using an array is probably better. See here for more details.
With instance_variable_set:
class Box
attr_reader :name, :row, :column
attr_accessor :is_marked, :contents
def initialize(name, row, column, is_marked=false, contents)
#name = name
#row = row
#column = column
#is_marked = is_marked
#contents = contents
end
def display_box
print '|#{contents}|'
end
end
#generate box instances
(1..9).each do |i|
if i > 3
col = i % 3
else
col = i
end
instance_variable_set("#box#{i}", Box.new('box#{i}', (i/3).ceil, col, false, '_'))
end
board = [[#box1, #box2, #box3], [#box4, #box5, #box6], [#box7, #box8, #box9]]
def display_board
#box1.display_box; #box2.display_box; #box3.display_box; print '\n'
#box4.display_box; #box5.display_box; #box6.display_box; print '\n'
#box7.display_box; #box8.display_box; #box9.display_box; print '\n'
end
display_board
With an array:
class Box
attr_reader :name, :row, :column
attr_accessor :is_marked, :contents
def initialize(name, row, column, is_marked=false, contents)
#name = name
#row = row
#column = column
#is_marked = is_marked
#contents = contents
end
def display_box
print '|#{contents}|'
end
end
#generate box instances
arr = [];
(1..9).each do |i|
if i > 3
col = i % 3
else
col = i
end
name = 'box' + i.to_s
arr.push(Box.new(name, (i/3).ceil, col, false, '_'))
end
board = [[arr[0], arr[1], arr[2]], [arr[3], arr[4], arr[5]], [arr[6], arr[7], arr[8]]]
def display_board(arr)
arr[0].display_box; arr[1].display_box; arr[2].display_box; print '\n'
arr[3].display_box; arr[4].display_box; arr[5].display_box; print '\n'
arr[6].display_box; arr[7].display_box; arr[8].display_box; print '\n'
end
display_board(arr)