This adds a chomp optional argument to IO#gets, IO#each_line, String#lines, String#each_line and generally to every method that reads lines, or by line.

This feature was added recently to Ruby 2.4, and honestly I always wanted to be able to do this, both in Ruby and Crystal, so keeping the way Ruby does it is good (I also imagined the same API before Ruby added it).

There's a slight difference with Ruby, though. The default chomp value in Ruby is always false. This is to preserve backwards compatibility, I guess. In our case breaking backwards compatibility is fine before 1.0. So, the rules are:

• argless gets, each_line and lines assume chomp = true
• other gets overloads assume chomp = false

The idea is that argless gets is semantically equivalent to reading a line. So in every case where we read a line, we chomp it if it ends with a newline (or "\r\n"). If we pass an argument to gets, for example gets('a'), we usually want to read up to, and including, that delimiter. Same goes with gets(3): we want to read a String of 3 bytes, please don't chomp it by default.

Note: I wouldn't mind having chomp = true in every case. I actually don't know what use cases exist for gets with a delimiter. If we make it always true by default it's maybe more consistent, and one can always pass chomp = false to disable this behaviour, so please share your thoughts and use cases about this.

In summary:

# No args, chomp is true by default
io = IO::Memory.new("one\ntwo\r\nthree")
io.gets # => "one"
io.gets # => "two"
io.gets # => "three"
io.gets # => nil

# No args, explicit chomp is false
io = IO::Memory.new("one\ntwo\r\nthree")
io.gets(chomp: false) # => "one\n"
io.gets(chomp: false) # => "two\r\n"
io.gets(chomp: false) # => "three"
io.gets(chomp: false) # => nil

# Passing a parameter will not implicitly chomp
io = IO::Memory.new("some long word")
io.gets('e') # => "some"
io.gets('g', chomp: true) # => "lon"

Of course one can always do gets.try &.chomp. The difference is that this will allocate two strings: one that is read, and one chomped. So chomp: true can also improve performance a bit if we don't care about the ending newline (and I'd say in most cases we don't).

As a side story, I was curious about what happens in these cases in Ruby 2.4:

"".lines
"\n".lines
"\r\n".lines

The first one returns an empty array. The second and third ones return an array with a single empty string. Well, almost, the second case actually triggers a segmentation fault, which I just reported. I just wanted to share this little story because it's a good change of air, from receiving segmentation faults and bug reports to Crystal, to be able to actually report one in another project (and help it become better, of course) 😸