Compare values in each loop - ruby

Question

I have an application whose purpose is to take in coordinates from the command line and output directions from 0,0 to each coordinate eg 0,0 to 1,1 would be EN as in East North. When application reaches that coordinate it would output D as in drop delivery. So if I enter:
“ ./testapplication.rb "5x5 (2, 2) (3, 5)"
The output is:
EENNDENNND
So far I have the following:
#!/home/eamonn/.rbenv/shims/ruby
instructions = ''
addresses = ARGV.to_s.scan(/\(([^\)]+)\)/)
starting_point = ['0, 0']
addresses.each do |point|
starting_point = starting_point[0].split(", ")
destination = point[0].split(", ")
x = destination[0].to_i - starting_point[0].to_i
y = destination[1].to_i - starting_point[1].to_i
if x < 0
instructions << 'W' * x.abs
elsif x > 0
instructions << 'E' * x
end
if y < 0
instructions << 'S' * y.abs
elsif y > 0
instructions << 'N' * y
end
instructions << "D"
starting_point = point
end
puts instructions
While the application works I feel there are a few problems with it such as the efficiency of the code so any pointers are appreciated.
Also I am used to writing ruby on rails applications but as I am writing this as a standalone ruby application I am a bit confused as to how I would run tests for this. I have been looking into using rspec and creating a spec folder and writing tests in there. The testing approach I am considering is:
describe 'testing that application' do
it 'should return the right directions' do
expect(navigate(["5x5 (2, 2) (3, 5)"])).to equal('EENNDENNND')
end
end
Any advice as to whether I should include testing for incorrect input here or just perform some error handling when ARGV is passed into addresses.

Answer 1

You can refactor your code like this.
def generate_instructions(input)
addresses = input.to_s.scan(/\(([^\)]+)\)/)
instructions = ''
# use like array
starting_point = [0, 0]
addresses.each do |point|
sx, sy = starting_point # will set 1. param like first value
arr = point[0].split(", ") # split by , and set inside array
dx, dy = arr[0].to_i, arr[1].to_i # set array inside variables and re-type to -integer
x = dx - sx
y = dy - sy
# add into instructions
instructions << (x < 0 ? 'W' * x.abs : 'E' * x)
instructions << (y < 0 ? 'S' * y.abs : 'N' * y)
instructions << 'D'
# reset points to destination (use it like array)
starting_point = [dx, dy]
end
instructions
end
puts generate_instructions(ARGV) if ARGV
For testing use RSpec
require './testapplication.rb'
describe 'Test output for generate_instructions' do
it 'return EENNDENNND' do
expect(generate_instructions(["5x5 (2, 2) (3, 5)"])).to be == 'EENNDENNND'
end
end
I hope this helps.

Answer 2

There are improvements that can be made, but just to address the subject of testing, here's one approach you could take. Refactor your code to put the process in a single method, like so...
#!/home/eamonn/.rbenv/shims/ruby
def navigate(input)
instructions = ''
addresses = input.to_s.scan(/\(([^\)]+)\)/)
starting_point = ['0, 0']
addresses.each do |point|
starting_point = starting_point[0].split(", ")
destination = point[0].split(", ")
x = destination[0].to_i - starting_point[0].to_i
y = destination[1].to_i - starting_point[1].to_i
if x < 0
instructions << 'W' * x.abs
elsif x > 0
instructions << 'E' * x
end
if y < 0
instructions << 'S' * y.abs
elsif y > 0
instructions << 'N' * y
end
instructions << "D"
starting_point = point
end
instructions
end
if $0 == __FILE__
puts navigate(ARGV)
end
The conditional at the bottom means you will only really take the ARGV values if you're running the script standalone. If it's included in a test script, then we don't.
to test it, you need...
spec/testapplication_spec.rb
require './testapplication.rb'
describe 'testing the navigate method' do
it 'should return the right value' do
expect(navigate(["5x5 (2, 2) (3, 5)"]).to eq('EENNDENNND')
end
end
So in the test you mimic the ARGV input that the navigate method would receive, to see if it returns the correct result.

Answer 3

Here is a more Ruby-like way of making that calculation.
str = ' ./testapplication.rb "5x5 (2, 2) (3, 5) (1, 2)"'
r = /
\( # match a left paren
(\d+) # match one or more digits in capture group 1
,[ ]+ # match a comma followed by one or more spaces
(\d+) # match one or more digits in capture group 2
\) # match a right paren
/x # free-spacing regex definition mode
(conventionally written /\((\d+), +(\d+)\\)/)1.
str.scan(r).
map { |pair| pair.map(&:to_i) }.
unshift([0,0]).
each_cons(2).
map do |(fx,fy), (tx,ty)|
ew = tx-fx
ns = ty-fy
"%s%sD" % [ew >= 0 ? 'E'*ew : 'W'*(-ew), ns > 0 ? 'N'*ns : 'S'*(-ns)]
end.join
#=> "EENNDENNNDWWSSSD"
The steps are as follows2.
a = str.scan(/\((\d+), +(\d+)\)/)
#=> [["2", "2"], ["3", "5"], ["1", "2"]
b = a.map { |pair| pair.map(&:to_i) }
#=> [[2, 2], [3, 5], [1, 2]]
c = b.unshift([0,0])
#=> [[0, 0], [2, 2], [3, 5], [1, 2]]
d = c.each_cons(2)
#=> #<Enumerator: [[0, 0], [2, 2], [3, 5], [1, 2]]:each_cons(2)>
We can see the elements that will be generated by the enumerator d by converting it to an array.
d.to_a
#=> [[[0, 0], [2, 2]], [[2, 2], [3, 5]], [[3, 5], [1, 2]]]
Continuing,
e = d.map do |(fx,fy), (tx,ty)|
ew = tx-fx
ns = ty-fy
"%s%sD" % [ew >= 0 ? 'E'*ew : 'W'*(-ew), ns > 0 ? 'N'*ns : 'S'*(-ns)]
end
#=> ["EENND", "ENNND", "WWSSSD"]
and lastly,
e.join
#=> "EENNDENNNDWWSSSD"
Consider the first element generated by the enumerator d and passed to the block. The block variables are assigned values using disambiguation (aka decomposition) and the block calculation is performed3.
(fx,fy), (tx,ty) = d.next
#=> [[0, 0], [2, 2]]
fx
#=> 0
fy
#=> 0
tx
#=> 2
ty
#=> 2
ew = tx-fx
#=> 2
ns = ty-fy
#=> 2
"%s%sD" % [ew >= 0 ? 'E'*ew : 'W'*(-ew), ns > 0 ? 'N'*ns : 'S'*(-ns)]
#-> "%s%sD" % [true ? 'E'*ew : 'W'*(-ew), true ? 'N'*ns : 'S'*(-ns)]
#-> "%s%sD" % ['E'*ew, 'N'*ns]
#=> "EENND"
The remaining calculations to produce e are similar.
1. When free-spacing regex definition mode is used spaces must be enclosed in character classes (as I've done) or protected in some other way, as all unprotected spaces are removed. Note that a space--followed by a plus sign--is present in the conventionally-written regex. Free-spacing mode has the advantage that it is self-documenting.
2. See String#scan, particularly the treatment of regex groups, Array#unshift and Enumerable#each_cons.
3. See Enumerator#next.