rubocop-hq/rubocop

== AllowMultilineFinalElement

`AllowMultilineFinalElement` is a boolean option (`false` by default) that
is available on the following Layout cops:

  * FirstArrayElementLineBreak
  * FirstHashElementLineBreak
  * FirstMethodArgumentLineBreak
  * FirstMethodParameterLineBreak
  * MultilineArrayLineBreaks
  * MultilineHashKeyLineBreaks
  * MultilineMethodArgumentLineBreaks
  * MultilineMethodParameterLineBreaks

Those cops ignore their respective expressions if all or the elements of
the expression are on the same line. If `AllowMultilineFinalElement` is
set to `true`, the cop will also ignore multiline expressions if the last
element starts on the same line, but ends on a different one.

This works well with `Layout/LineLength` to present elements on
individual lines when wrapping, while not affecting expressions
that are already short enough, and only considered multiline
because of their last element.

Each cop can be configured independently allowing for more fine-grained
control over what is considered good ok in the codebase.

=== Examples

Here are some examples of real world expressions that get wrapped
by their respective cops, but that are considered ok when setting
`AllowMultilineFinalElement` to `true` on those same cops.

[source,ruby]
----
# good

# FirstArrayElementLineBreak and MultilineArrayLineBreaks

  # Array of error containing a single error
  errors = [{
    error: "Something went wrong",
    error_code: error_code,
  }]

  # Array of flags, with last flag computed
  flags = [:a, :b, foo(
    bar,
    baz
  )]

# FirstHashElementLineBreak and MultilineHashKeyLineBreaks
  hash = { foo: 1, bar: 2, baz: {
    c: 1,
    d: 2
  }}

# FirstMethodArgumentLineBreak and MultilineMethodArgumentLineBreaks
  single_argument_hash_method_call({
    a: 1,
    b: 2,
    c: 3
  })

  # Call some method, with a long last argument, that is a hash
  write_log(:error,  {
    "job_class" => job.class.name,
    "resource" => resource.id,
    "message" => "Something wrong happened here",
  })

  # Rails before action with long last argument
  before_action :load_something, only: [
    :show,
    :list,
    :some_other_long_action_name,
  ]

  # Rails validation with inline callback
  validate :name, presence: true, on: [:create, :activate], if: -> {
    active? && some_relationship.any?
  }

  # Rails after commit hook, with some Sorbet bindings
  after_commit :geolocate, unless: -> {
    T.bind(self, Address)
    archived? || invalid?
  }

# FirstMethodParameterLineBreak and MultilineMethodParameterLineBreaks

  # Method with a long last parameter default value
  def foo(foo, bar, baz = {
    a: 1,
    b: 2,
    c: 3
  })
    do_something
  end
----