Ruby elegant alternative to ++ in nested loops?

Question

Before anything, I have read all the answers of Why doesn't Ruby support i++ or i—? and understood why. Please note that this is not just another discussion topic about whether to have it or not.

What I'm really after is a more elegant solution for the situation that made me wonder and research about ++/-- in Ruby. I've looked up loops, each, each_with_index and things alike but I couldn't find a better solution for this specific situation.

Less talk, more code:

# Does the first request to Zendesk API, fetching *first page* of results
all_tickets = zd_client.tickets.incremental_export(1384974614)

# Initialises counter variable (please don't kill me for this, still learning! :D )
counter = 1

# Loops result pages
loop do

  # Loops each ticket on the paged result
  all_tickets.all do |ticket, page_number|
    # For debug purposes only, I want to see an incremental by each ticket
    p "#{counter} P#{page_number} #{ticket.id} - #{ticket.created_at} | #{ticket.subject}"
    counter += 1
  end

  # Fetches next page, if any
  all_tickets.next unless all_tickets.last_page?

  # Breaks outer loop if last_page?
  break if all_tickets.last_page?

end

For now, I need counter for debug purposes only - it's not a big deal at all - but my curiosity typed this question itself: is there a better (more beautiful, more elegant) solution for this? Having a whole line just for counter += 1 seems pretty dull. Just as an example, having "#{counter++}" when printing the string would be much simpler (for readability sake, at least).

I can't simply use .each's index because it's a nested loop, and it would reset at each page (outer loop).

Any thoughts?

BTW: This question has nothing to do with Zendesk API whatsoever. I've just used it to better illustrate my situation.

Answer 1

To me, counter += 1 is a fine way to express incrementing the counter.

You can start your counter at 0 and then get the effect you wanted by writing:

p "#{counter += 1} ..."

But I generally wouldn't recommend this because people do not expect side effects like changing a variable to happen inside string interpolation.

If you are looking for something more elegant, you should make an Enumerator that returns integers one at a time, each time you call next on the enumerator.

nums = Enumerator.new do |y|
  c = 0
  y << (c += 1) while true
end

nums.next  # => 1
nums.next  # => 2
nums.next  # => 3

Instead of using Enumerator.new in the code above, you could just write:

nums = 1.upto(Float::INFINITY)

Answer 2

all_tickets.each_with_index(1) do |ticket, i|

I'm not sure where page_number is coming from...

See Ruby Docs.

Answer 3

As mentioned by B Seven each_with_index will work, but you can keep the page_number, as long all_tickets is a container of tuples as it must be to be working right now.

all_tickets.each_with_index do |ticket, page_number, i|
   #stuff
end

Where i is the index. If you have more than ticket and page_number inside each element of all_tickets you continue putting them, just remember that the index is the extra one and shall stay in the end.

Answer 4

Could be I oversimplified your example but you could calculate a counter from your inner and outer range like this.

all_tickets = *(1..10)
inner_limit = all_tickets.size
outer_limit = 5000
1.upto(outer_limit) do |outer_counter|
  all_tickets.each_with_index do |ticket, inner_counter|
    p [(outer_counter*inner_limit)+inner_counter, outer_counter, inner_counter, ticket]
  end
  # some conditional to break out, in your case the last_page? method
  break if outer_counter > 3
end