Соглашение Ruby для цепочки вызовов по нескольким линиям

Каковы соглашения для этого?

Я использую следующий стиль, но не уверен, что он является предпочтительным, поскольку, если я пропущу точку в конце, я могу столкнуться с проблемой, не понимая этого.

query = reservations_scope.for_company(current_company).joins{property.development}.
  group{property.development.id}.
  group{property.development.name}.
  group{property.number}.
  group{created_at}.
  group{price}.
  group{reservation_path}.
  group{company_id}.
  group{user_id}.
  group{fee_paid_date}.
  group{contract_exchanged_date}.
  group{deposit_paid_date}.
  group{cancelled_date}.
  select_with_reserving_agent_name_for(current_company, [
                                       "developments.id as dev_id",
                                       "developments.name as dev_name",
                                       "properties.number as prop_number",
                                       "reservations.created_at",
                                       "reservations.price",
                                       "reservations.fee_paid_date",
                                       "reservations.contract_exchanged_date",
                                       "reservations.deposit_paid_date",
                                       "reservations.cancelled_date"
  ]).reorder("developments.name")
query.to_a # ....

Итак, каковы соглашения для цепочки методов над несколькими строками и какой из них я должен предпочесть?

ПРИМЕЧАНИЕ. Я не смог найти хороший пример из Ruby style style guide.

Ответы

Ответ 1

На самом деле есть раздел, описанный в Руководстве по стилю Ruby:

Принять последовательный многострочный метод цепочки. Есть два популярные стили в сообществе Ruby, оба из которых считаются хороший - ведущий . (вариант A) и завершающий . (вариант B).

  • (вариант A). При продолжении вызова метода в цепочке другая строка сохранит . во второй строке.

    # bad - need to consult first line to understand second line
one.two.three.
  four

# good - it immediately clear what going on the second line
one.two.three
  .four

  • (вариант B). При продолжении вызова в цепочке в другой строке, включите . в первую строку, чтобы указать, что выражение продолжается.

    # bad - need to read ahead to the second line to know that the chain continues
one.two.three
  .four

# good - it immediately clear that the expression continues beyond the first line
one.two.three.
  four

Можно найти дискуссию о достоинствах обоих альтернативных стилей здесь.

Ответ 2

В Ruby 1.9+ можно написать вот так:

query = reservations_scope
  .for_company(current_company)
  .joins{property.development}
  .group{property.development.id}
  .group{property.development.name}
  .group{property.number}
  .group{created_at}
  .group{price}
  .group{reservation_path}
  .group{company_id}
  .group{user_id}

Намного более читаемым, я думаю.

Ответ 3

Вот полный список плюсов и минусов из четырех вариантов. Два варианта не упоминались ни в одном другом ответе.

. в конце строки

items.get.lazy.
  take(10).
  force
Уникальные плюсы:

(нет - все профи разделяются с другим вариантом)

Уникальные минусы:
  • Продолжающаяся линия выглядит странно сама по себе. Вы должны прочитать предыдущую строку, чтобы понять, что это продолжение.
    • Отступ не является надежным индикатором того, что линия продолжается от предыдущей строки - это может означать только начало блока.

. в начале строки

items.get.lazy
  .take(10)
  .force
Уникальные плюсы:
  • При редактировании кода проще изменить порядок последней строки - нет необходимости удалять и добавлять . или \.
Уникальные минусы:
  • Когда вы читаете начальную строку, ее не сразу видно, что выражение продолжается
    • Если вы используете это в своей кодовой базе, тогда, когда вы читаете строку, вы всегда должны проверять строку после того, как убедиться, что она не влияет на значения исходных строк.
  • Коротко разрывается код, если вы # закомментируете продолжение строки или добавьте комментарий между строками
  • Вы не можете вставить этот код в IRB/Pry без его неправильного толкования.
  • Не поддерживается в Ruby 1.8 и ниже

Вариант: . в начале строки, с отступом до предыдущего .

items.get.lazy
         .take(10)
         .force
Плюсы относительно ". при начале строки":
  • Когда вы читаете начальную строку, теперь сразу становится ясно, что выражение продолжается
Минусы относительно ". в начале строки":
  • Каждый код строки должен помещаться в меньшее горизонтальное пространство
  • Требуется ручное выравнивание . s
    • Это проще, если у вас есть плагин редактора для выравнивания текста, но еще больше работы, чем использование стандартных правил отступов.
    • Даже если ваша настройка редактирования включает плагин для выравнивания, настройки ваших коллег могут не совпадать.
  • Код будет выглядеть несогласованным при просмотре в пропорциональном шрифте

\ на конце строки, . при следующих строках

items.get.lazy \
  .take(10) \
  .force
Уникальные плюсы:

(нет - все профи разделяются с другим вариантом)

Уникальные минусы:
  • Требуется больше ввода
  • Создает больше визуального шума.

Ответ 4

Причина, по которой я выбираю точку в конце строки, заключается в том, что она позволит вам вставлять код в сеанс IRB. Кроме того, вы не можете комментировать строки в середине многострочного кода, если вы используете точки в начале строк. Здесь хорошее обсуждение: https://github.com/bbatsov/ruby-style-guide/pull/176