Ruby whitespace: Is { :a => 1 } better than {:a => 1}?

Question

Looking at other people's code it seems really common to include an extra space inside curly brace blocks. Is there a reason for that? To me it seems to add extra keystrokes for added ugliness. Especially when things get nested:

lambda { (1..5).map { |i| { :a => { :b => i } } } }

For some reason it just looks more concise and coherent to do:

lambda {(1..5).map {|i| {:a => {:b => i}}}}

Maybe the extra spaces are some text editor side effect or there is a historical reason or something? I haven't seen this addressed in style guides and if it's like 2 space indentation I want to follow conventions, but if there's no good reason I guess I'll just keep doing things my own way. Which do you prefer, and why?

Answer 1

I'm not Ruby programmer, but I tend to put extra space after brackets/parenthesis, if I have something longer between them - i.e. longer if statement or extra calculation as argument to a function.

So I would say - although I'm not Ruby programmer - do as you wish / as your employer (if you're not freelancer/hobbyist) wishes.

Answer 2

Seems like just a matter of style. I think they're ugly, leave out the extra spaces.

Edit: I do agree with the comment below that just saying it's a matter of style doesn't give a license to do whatever you want. If anyone else is ever going to have to read or maintain the code then adhering to a common style is just good coding practice. So I'd be the first person to put in spaces if someone convinced me that most Ruby code uses spaces in this manner. Personally I still think it's ugly but that's far less important than having others be able to read my code.

Answer 3

Most of the Ruby code I see (and hopefully all the code I write) uses this style:

{ :key => 'value' }

This is what I have gotten used to and internalized.

When all is said and done, this one particular style issue is not of paramount importance. That said, the Ruby community (as do others) believes it is important to match your style (a) to the project you are working with and (b) to the community of code as a whole. That's why I recommend to use the extra white spaces.

BTW, this is a good Ruby style guide: http://www.caliban.org/ruby/rubyguide.shtml#style

Answer 4

The example you show is a matter of style. I think you take the spaces out if you're going to put it all on one line. However, if you put

[1,2,3].slice (2)

in your code, Ruby gives you a warning

warning: don't put space before argument parentheses

So, I guess Ruby is passionate about the parenthesis, but not the braces.

Answer 5

You can use a combination. At a place I used to work, we had a somewhat fuzzy style rule that said "use spaces inside brackets except when they're the outer brackets of a structure." This sounds confusing, but it often helps you arrive at something which makes nice intuitive visual sense.

lambda {(1..5).map {|i| {:a => { :b => i }} }}

I like how this spacing sets off the inner hash (return value), without it feeling too smushed, and the trailing }} helps you see that it's encased by two levels of nesting.

Answer 6

Up to a point, I think it's a matter of personal taste. Normally I find adding white space helps readability - but not always. In your example, personally, I would:

lambda{ (1..5).map{ |i| {:a=>{:b=>i}} } }

Of course, if you find it problematic to read, you almost always have the option of not using a lambda, if you prefer.

If you're coding with a group of other people -- or for the specific purpose of showing your code to the Ruby community -- you also have to consider what they will find readable.

But I'm not sure I care that strongly whether my example above is "normal ruby spacing".

Answer 7

The extra space at the start/ends of hashes was probably made good style to improve readability on key/values that start/end with anything but a letter.

{:a => "b"} #is less readable than
{ :a => "b" } #more readable.

It's in part attributed to the curly brackets, I rarely see spaces at the start of hashes in Ruby ([]).
The new hash syntax introduced in Ruby 1.9 shall probably modify this

{a: "b"} #same as {:a => "b"}

Answer 8

I've always thought it was most readable to include the extra space inside curly brace blocks, but omit the last space if the preceding character is a closing brace. To use your example:

lambda { (1..5).map { |i| { :a => { :b => i }}}}