Issue #14463 has been updated by isiahmeadows (Isiah Meadows).


shevegen (Robert A. Heiler) wrote:
> > I still find it very odd that it's inconsistent.
> 
> Tsuyoshi Sawada pointed out something similar in the issue that
> was referred to 5 years ago and I also agree with it.
> 
> I know little to nothing how ruby works internally but I would
> have assumed that comments are completely ignored. Like "hello
> ruby parser, ignore everything that comes on the line after a
> '#' token". I should, however had, also say that I do not think
> that I was ever affected by it; I don't think I wrote a .foo
> method call on the next line, ever, in all my years of ruby. :)
> 

It wasn't more than a month in that I first got bit. Like I said earlier, Ruby isn't my primary language (I started with Java, and JavaScript is my primary), so writing method calls on new lines is practically muscle memory at this point. Most other languages idiomatically prefer this, including those two languages, Python, Lua, and others.

> The only excessive method chaining I sometimes do, but also quite
> rarely, is something like this (semi-contrived):
> 
>     object.sub(//,'').sub(//,'').sub(//,'').sub(//,'').
>            sub(//,'').sub(//,'').sub(//,'').sub(//,'')
> 
> And I already considered that pretty strange to do, but I do that
> very rarely ... though never with the '.' dot on a newline.

I've had method chains longer than that come up frequently, as:

1. I have a bit of a functional background and find myself using array methods quite a bit. Those can result in non-trivial method chains on occasion.
2. My company's main app is a pretty large, CRUD-ish app, so we do a *lot* of ActiveRecord queries (in a few files, there's several query chains that long).


----------------------------------------
Feature #14463: Allow comments to precede dots in member expressions
https://bugs.ruby-lang.org/issues/14463#change-70723

* Author: isiahmeadows (Isiah Meadows)
* Status: Open
* Priority: Normal
* Assignee: 
* Target version: 
----------------------------------------
I, coming from other languages, find it *extremely* odd that the first three are considered valid, but the fourth is a syntax error (tested in Ruby 2.3.4 + 2.5.0, Rubocop's parser for 2.3):

~~~ ruby
# 1
foo = -> {}
foo.
  call

# 2
foo = -> {}
foo.
  # comment
  call

# 3
foo = -> {}
foo
  .call

# 4
foo = -> {}
foo
  # comment
  .call
~~~

Any chance 4 could be fixed? (It looks more like a parser/spec bug than anything.)



-- 
https://bugs.ruby-lang.org/

Unsubscribe: <mailto:ruby-core-request / ruby-lang.org?subject=unsubscribe>
<http://lists.ruby-lang.org/cgi-bin/mailman/options/ruby-core>