[PATCH] String#squish as a heredoc alternative.

Almost forgot, an example of usage:

@description = %{ String#squish() allows me to write long strings
  inside my Ruby code, without having to worry about indentation,
  the page margin, spaces, tabs or newlines. "double" or 'single'
  quotes are both fine, and #{interpolation} works. }.squish

And another:

@elephants = Elephant.find_by_sql %{
  SELECT foo, bar FROM elephants
    INNER JOIN /* complicated joins ... */      
    WHERE      /* complicated conditions ... */
    /* etc, etc ... */
}.squish

I suppose it can be achieved by chaining string methods, but anyway wont hurt to have this as a method. Nice one. +1 for the idea

+1, useful as hell

As someone who's written code like this:

totals = InnovationInterestScore.find_by_sql(<<-END_SQL.gsub(/\s+/, " ").strip)
    SELECT
      #{ifs} AS i, AVG(percentile) AS total
    FROM
      innovation_interest_scores 
    WHERE
      #{conditions ? conditions + ' AND' : ''} monthly_sum = true #{selected_weight ? ' AND ' + 'weight_id=' + selected_weight.id.to_s : ''}
    GROUP BY
      i
    ORDER BY
      i
    END_SQL
  end

This method is nice -- and does the exact same thing!

+1 for usefulness, tiny-ness, and good documentation

+1 documented and tested

+1.

But any particular reason you do

def squish 
  dup.squish! 
end 

# Performs a destructive squish. See String.squish. 
def squish! 
  strip! 
  gsub!(/\s+/, ' ') 
  self 
end

instead of the shorter and simpler

def squish 
  strip.gsub(/\s+/, ' ')
end 

# Performs a destructive squish. See String.squish. 
def squish!
  replace(strip)
end

?

Some mods.

The attached diff makes the change in my comment above, says "See String#squish" rather than "String.squish" and adds a test assertion to verify that String#squish isn't destructive.

…and the patch also has replace(strip) (typo by me in the comment above) fixed to replace(squish). Sorry for the million comments.

I didn't know about replace, actually. As long as both squish and squish! still return the same squished string, I don't see why I would care.

As I understand it, the original one will only allocate space for a new string when doing String#squish, whereas the modded version does a new allocation for both that and the bang'd version.

The difference is minimal, but I'd rather go with two lines longer, equally as clear, and not allocating new objects.

The modified one about is 33% slower than the original.

Benchmark.bm(10) do |b|

?> n = 1_000_000

s = " this\n\n\t is a string \t\t with some extra \n spaces\n" b.report("no alloc:") { n.times { s.dup.squish_one! } } b.report(" alloc:") { n.times { s.dup.squish_two! } } end

user system total real

no alloc: 2.890000 0.020000 2.910000 ( 2.906246)

alloc: 3.930000 0.020000 3.950000 ( 3.951751)

Replying to jordi:

I didn't know about replace, actually. As long as both squish and squish! still return the same squished string, I don't see why I would care.

A minor matter for sure. Would love the method no matter the implementation; thanks a lot for contributing it.

stouset: Yes, came to the same realization after submitting the patch. Thanks for the benchmark :)

"String.squish" -> "String#squish" should of course be fixed, but nevermind the rest, then.

Teach me not to preview first.

>> Benchmark.bm(10) do |b|
?>   n = 1_000_000
>>   s = "  this\n\n\t is a   string \t\t with  some     extra \n spaces\n"
>>   b.report("no alloc:") { n.times { s.dup.squish_one! } }
>>   b.report("   alloc:") { n.times { s.dup.squish_two! } }
>> end
                user     system      total        real
no alloc:   2.890000   0.020000   2.910000 (  2.906246)
   alloc:   3.930000   0.020000   3.950000 (  3.951751)

I'm sloppy today. Here's the definition of those methods in String.

>> class String
>>   def squish_one!
>>     strip!
>>     gsub! %{\s+}, ' '
>>     self
>>   end
>>   def squish_two!
>>     replace(strip.gsub(%{\s+}, ' '))
>>   end
>> end

stouset: Likely doesn't change which implementation is quicker, but gsub(%{\s+}, ' ') will replace a string, not a regexp (%r{…}).

Replying to Henrik N:

Replying to jordi:

I didn't know about replace, actually. As long as both squish and squish! still return the same squished string, I don't see why I would care.

A minor matter for sure. Would love the method no matter the implementation; thanks a lot for contributing it. "String.squish" -> "String#squish" should of course be fixed, but nevermind the rest, then.

No, the extra test you added should stay too. The one that makes sure squish is not destructive, only squish!

Replying to Henrik N:

stouset: Likely doesn't change which implementation is quicker, but gsub(%{\s+}, ' ') will replace a string, not a regexp (%r{…}).

Thanks. The first implementation is still faster, but it's 10.65s to 11.27s, now.

(In [8878]) Add String#squish and String#squish! to remove consecutive chunks of whitespace. Closes #11123 [jordi, Henrik N]

The wrong version of the patch seems to have been applied.

Faster version of String#squish!

The attached fast_banged_squish.diff is the faster version that stouset is talking about. The patch applies on top of [8992].

(In [9015]) Applied the faster squish version (closes #11123) [jordi]