Issue when combining ClosingParenthesisIndentation and AlignParameters:with_fixed_indentation

[bquorning]

I like to configure Style/AlignParameters with EnforcedStyle: with_fixed_indentation, which would allow me code like this:

puts(1,
  foo: 'bar',
  one: 'two'
)

On the latest master (933d084), Style/ClosingParenthesisIndentation tells me to indent the closing parenthesis:

puts(1,
  foo: 'bar',
  one: 'two'
    )

I could move the 1 argument to a separate line, but I would rather keep the non-hash arguments on the same line as the method call, and the options hash on separate lines. Explicitly, I guess it would be:

puts(1, {
  foo: 'bar',
  one: 'two'
})

[bbatsov]

That's not a style worth supporting IMO as it's not exactly common. To be honest I've never seen Ruby code indented like this until just now...

[bquorning]

I'm not sure how this code can be formatted then, given this combination of configurations. I could disable one of the cops, I guess :-)

[bbatsov]

Pretty sure the only two common indentation schemes for this bit of code are:

puts(1,
     foo: 'bar',
     one: 'two')

puts(
  1,
  foo: 'bar',
  one: 'two'
)

[digitalcora]

Just chiming in that I've seen this style used with some frequency when a method has a single initial parameter that is not a hash, followed by hash parameters. Example from some Factory Girl code in a Rails project:

create(:store,
  name: 'Downtown Boutique',
  address: '123 Main St, Anytown, USA'
)

To me at least, the equivalent cop-compliant code is harder to read, because the initial parameter is given the same visual "precedence" as the hash parameters, even though it is a completely separate and more important element:

create(
  :store,
  name: 'Downtown Boutique',
  address: '123 Main St, Anytown, USA'
)

I have no strong opinion on whether this exact style should be enforceable via Rubocop, but as it stands, merely using the style means that you have to forego ClosingParenthesisIndentation altogether. (I feel like maybe this should be treated as a bug, since taking the cop's suggestion literally results in a very odd style that I doubt was intended – @bquorning's second example in the first post)

[kaspernj]

+1

[alexdowad]

Pretty sure the only two common indentation schemes for this bit of code are:

And one of the two you show is what @bquorning is asking for...

[alexdowad]

And one of the two you show is what @bquorning is asking for

Whoops, I was wrong. Sorry, @bbatsov.

[alexdowad]

I can code up a PR for this, but what should the config parameter which enables this style in Style/ClosingParenthesisIndentation be called?

[alexdowad]

Ping.

Do we want this style added to ClosingParenthesisIndentation? Or is @bquorning just out of luck?

[jonas054]

Would this style also apply for method definitions and grouped expressions? I think we (or the person doing the implementation) need to see all examples before we can decide on what to call the configuration parameter/values. For reference, here's what's currently accepted:

      some_method(
        a
      )

      x = some_method(
        a
      )

      x =
        some_method(
          a
        )

      some_method(a
                 )

      some_method()

      def some_method(
        a
      )
      end

      private def some_method(
        a
      )
      end

      private def some_method(a
                             )
      end

      def some_method(a
                     )
      end

      def some_method()
      end

      w = x * (
        y + z
      )

      w = x * (y + z
              )

      w = x * (y + z +
              a)

      w = x * (y + z +
              a
              )

[aeberlin]

👍

[alexdowad]

@bquorning, what do you think of @jonas054's comment? Are you looking for a new style specific to method calls, or should it be for grouped expressions (using parens) as well?

[bquorning]

What I was looking for was well described by @Grantovich as

when a method has a single initial parameter that is not a hash, followed by hash parameters.

So yes, only for method calls.

[wjordan]

For some real-world examples of this style in the wild, see code-dot-org/code-dot-org#7562. (We're blacklisting the Style/ClosingParenthesisIndentation cop because of this issue.)

[gaffneyc]

We use this style quite a bit when we have one (or a few) non-hash params followed by a hash or keywords. Moving the non-hash arguments to the first line muddles the distinction between what is an argument and what is in the hash.