布局

Layout/AccessModifierIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

裸访问修饰符（不应用于特定方法的修饰符）应缩进到与方法定义相同的深度，或与类/模块关键字相同的深度，具体取决于配置。

示例

EnforcedStyle: indent（默认）

# bad
class Plumbus
private
  def smooth; end
end

# good
class Plumbus
  private
  def smooth; end
end

EnforcedStyle: outdent

# bad
class Plumbus
  private
  def smooth; end
end

# good
class Plumbus
private
  def smooth; end
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

indent

outdent, indent

IndentationWidth

<none>

整数

参考

Layout/ArgumentAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.68

0.77

这里我们检查多行方法定义中的参数是否对齐。

示例

EnforcedStyle: with_first_argument（默认）

# good

foo :bar,
    :baz,
    key: value

foo(
  :bar,
  :baz,
  key: value
)

# bad

foo :bar,
  :baz,
  key: value

foo(
  :bar,
    :baz,
    key: value
)

EnforcedStyle: with_fixed_indentation

# good

foo :bar,
  :baz,
  key: value

# bad

foo :bar,
    :baz,
    key: value

可配置属性

名称 默认值 可配置值

EnforcedStyle

with_first_argument

with_first_argument, with_fixed_indentation

IndentationWidth

<none>

整数

参考

Layout/ArrayAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.77

这里我们检查多行数组文字的元素是否对齐。

示例

EnforcedStyle: with_first_element（默认）

# good

array = [1, 2, 3,
         4, 5, 6]
array = ['run',
         'forrest',
         'run']

# bad

array = [1, 2, 3,
  4, 5, 6]
array = ['run',
     'forrest',
     'run']

EnforcedStyle: with_fixed_indentation

# good

array = [1, 2, 3,
  4, 5, 6]

# bad

array = [1, 2, 3,
         4, 5, 6]

可配置属性

名称 默认值 可配置值

EnforcedStyle

with_first_element

with_first_element, with_fixed_indentation

IndentationWidth

<none>

整数

参考

Layout/AssignmentIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.45

检查多行赋值右侧第一行的缩进。

剩余行的缩进可以使用其他 cops 来修正，例如 IndentationConsistency 和 EndAlignment。

示例

# bad
value =
if foo
  'bar'
end

# good
value =
  if foo
    'bar'
  end

可配置属性

名称 默认值 可配置值

IndentationWidth

<none>

整数

Layout/BeginEndAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.91

-

检查 begin 的结束关键字是否正确对齐。

通过 EnforcedStyleAlignWith 配置参数支持两种模式。如果设置为 start_of_line（默认值），则 end 应与 begin 关键字所在行的开头对齐。如果设置为 begin，则 end 应与 begin 关键字对齐。

Layout/EndAlignment cop 默认与关键字（例如 if、while、case）对齐。另一方面，此 cop 目标的 ||= begin 倾向于与行的开头对齐，它默认为 EnforcedStyleAlignWith: start_of_line。这些样式可以通过每个 cop 进行配置。

示例

EnforcedStyleAlignWith: start_of_line（默认值）

# bad
foo ||= begin
          do_something
        end

# good
foo ||= begin
  do_something
end

EnforcedStyleAlignWith: begin

# bad
foo ||= begin
  do_something
end

# good
foo ||= begin
          do_something
        end

可配置属性

名称 默认值 可配置值

EnforcedStyleAlignWith

start_of_line

start_of_line、begin

严重性

警告

字符串

Layout/BlockAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.53

-

检查 do end 块的结束关键字是否正确对齐。

通过 EnforcedStyleAlignWith 配置参数支持三种模式

start_of_block：end 应与 do 出现的行的开头对齐。

start_of_line：end 应与表达式开始的行的开头对齐。

either（默认值）：end 允许在任一位置。自动修正器将默认为 start_of_line。

示例

EnforcedStyleAlignWith: either（默认值）

# bad

foo.bar
  .each do
    baz
      end

# good

foo.bar
  .each do
    baz
end

EnforcedStyleAlignWith: start_of_block

# bad

foo.bar
  .each do
    baz
      end

# good

foo.bar
  .each do
    baz
  end

EnforcedStyleAlignWith: start_of_line

# bad

foo.bar
  .each do
    baz
      end

# good

foo.bar
  .each do
    baz
end

可配置属性

名称 默认值 可配置值

EnforcedStyleAlignWith

任一

either、start_of_block、start_of_line

Layout/BlockEndNewline

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 do..end 块的结束语句是否在单独一行上。

示例

# bad
blah do |i|
  foo(i) end

# good
blah do |i|
  foo(i)
end

# bad
blah { |i|
  foo(i) }

# good
blah { |i|
  foo(i)
}

Layout/CaseIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.16

检查 case 表达式的 when 和 in 相对于其 case 或 end 关键字的缩进方式。

它将为每个未对齐的 when 和 in 注册一个单独的违规。

示例

# If Layout/EndAlignment is set to keyword style (default)
# *case* and *end* should always be aligned to same depth,
# and therefore *when* should always be aligned to both -
# regardless of configuration.

# bad for all styles
case n
  when 0
    x * 2
  else
    y / 3
end

case n
  in pattern
    x * 2
  else
    y / 3
end

# good for all styles
case n
when 0
  x * 2
else
  y / 3
end

case n
in pattern
  x * 2
else
  y / 3
end

EnforcedStyle: case (默认)

# if EndAlignment is set to other style such as
# start_of_line (as shown below), then *when* alignment
# configuration does have an effect.

# bad
a = case n
when 0
  x * 2
else
  y / 3
end

a = case n
in pattern
  x * 2
else
  y / 3
end

# good
a = case n
    when 0
      x * 2
    else
      y / 3
end

a = case n
    in pattern
      x * 2
    else
      y / 3
end

EnforcedStyle: end

# bad
a = case n
    when 0
      x * 2
    else
      y / 3
end

a = case n
    in pattern
      x * 2
    else
      y / 3
end

# good
a = case n
when 0
  x * 2
else
  y / 3
end

a = case n
in pattern
  x * 2
else
  y / 3
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

case

case、end

IndentOneStep

false

布尔值

IndentationWidth

<none>

整数

参考

Layout/ClassStructure

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终（不安全）

0.52

1.53

检查代码风格是否遵循 ExpectedOrder 配置

Categories 允许我们将宏名称映射到类别。

考虑一个涵盖以下顺序的代码风格示例

  • 模块包含（include、prepend、extend）

  • 常量

  • 关联（has_one、has_many）

  • 公共属性宏（attr_accessor、attr_writer、attr_reader）

  • 其他宏（validates、validate）

  • 公共类方法

  • 初始化器

  • 公共实例方法

  • 受保护的属性宏（attr_accessor、attr_writer、attr_reader）

  • 受保护的实例方法

  • 私有属性宏（attr_accessor、attr_writer、attr_reader）

  • 私有实例方法

您可以配置以下顺序

 Layout/ClassStructure:
   ExpectedOrder:
     - module_inclusion
     - constants
     - association
     - public_attribute_macros
     - public_delegate
     - macros
     - public_class_methods
     - initializer
     - public_methods
     - protected_attribute_macros
     - protected_methods
     - private_attribute_macros
     - private_delegate
     - private_methods

除了将所有文字按预期顺序放置外，还可以对宏类别进行分组。可见性级别会自动处理。

 Layout/ClassStructure:
   Categories:
     association:
       - has_many
       - has_one
     attribute_macros:
       - attr_accessor
       - attr_reader
       - attr_writer
     macros:
       - validates
       - validate
     module_inclusion:
       - include
       - prepend
       - extend

安全

自动更正是不安全的，因为类方法和模块包含的行为可能不同，具体取决于已经定义了哪些方法或常量。

常量仅在使用文字进行赋值时才会移动。

示例

# bad
# Expect extend be before constant
class Person < ApplicationRecord
  has_many :orders
  ANSWER = 42

  extend SomeModule
  include AnotherModule
end

# good
class Person
  # extend and include go first
  extend SomeModule
  include AnotherModule

  # inner classes
  CustomError = Class.new(StandardError)

  # constants are next
  SOME_CONSTANT = 20

  # afterwards we have public attribute macros
  attr_reader :name

  # followed by other macros (if any)
  validates :name

  # then we have public delegate macros
  delegate :to_s, to: :name

  # public class methods are next in line
  def self.some_method
  end

  # initialization goes between class methods and instance methods
  def initialize
  end

  # followed by other public instance methods
  def some_method
  end

  # protected attribute macros and methods go next
  protected

  attr_reader :protected_name

  def some_protected_method
  end

  # private attribute macros, delegate macros and methods
  # are grouped near the end
  private

  attr_reader :private_name

  delegate :some_private_delegate, to: :name

  def some_private_method
  end
end

可配置属性

名称 默认值 可配置值

类别

{"module_inclusion"⇒["include", "prepend", "extend"]}

ExpectedOrder

module_inclusion、constants、public_class_methods、initializer、public_methods、protected_methods、private_methods

数组

参考

Layout/ClosingHeredocIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.57

-

检查 here document 结束处的缩进。

示例

# bad
class Foo
  def bar
    <<~SQL
      'Hi'
  SQL
  end
end

# good
class Foo
  def bar
    <<~SQL
      'Hi'
    SQL
  end
end

# bad

# heredoc contents is before closing heredoc.
foo arg,
    <<~EOS
  Hi
    EOS

# good
foo arg,
    <<~EOS
  Hi
EOS

# good
foo arg,
    <<~EOS
      Hi
    EOS

Layout/ClosingParenthesisIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查方法调用、方法定义和分组表达式中悬挂的右括号的缩进。悬挂的右括号是指在 ) 之前有换行符。

示例

# bad
some_method(
  a,
  b
  )

some_method(
  a, b
  )

some_method(a, b, c
  )

some_method(a,
            b,
            c
  )

some_method(a,
  x: 1,
  y: 2
  )

# Scenario 1: When First Parameter Is On Its Own Line

# good: when first param is on a new line, right paren is *always*
#       outdented by IndentationWidth
some_method(
  a,
  b
)

# good
some_method(
  a, b
)

# Scenario 2: When First Parameter Is On The Same Line

# good: when all other params are also on the same line, outdent
#       right paren by IndentationWidth
some_method(a, b, c
           )

# good: when all other params are on multiple lines, but are lined
#       up, align right paren with left paren
some_method(a,
            b,
            c
           )

# good: when other params are not lined up on multiple lines, outdent
#       right paren by IndentationWidth
some_method(a,
  x: 1,
  y: 2
)

Layout/CommentIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.24

检查注释的缩进。

示例

# bad
  # comment here
def method_name
end

  # comment here
a = 'hello'

# yet another comment
  if true
    true
  end

# good
# comment here
def method_name
end

# comment here
a = 'hello'

# yet another comment
if true
  true
end

AllowForAlignment: false (默认)

# bad
a = 1 # A really long comment
      # spanning two lines.

# good
# A really long comment spanning one line.
a = 1

AllowForAlignment: true

# good
a = 1 # A really long comment
      # spanning two lines.

可配置属性

名称 默认值 可配置值

AllowForAlignment

false

布尔值

Layout/ConditionPosition

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.53

0.83

检查不在与 if/while/until 相同行上的条件。

示例

# bad

if
  some_condition
  do_something
end
# good

if some_condition
  do_something
end

参考

Layout/DefEndAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.53

-

检查方法定义的 end 关键字是否对齐。

通过 EnforcedStyleAlignWith 配置参数支持两种模式。如果设置为 start_of_line（默认值），则 end 应与 def 关键字所在行的开头对齐。如果设置为 def，则 end 应与 def 关键字对齐。

示例

EnforcedStyleAlignWith: start_of_line (默认)

# bad

private def foo
            end

# good

private def foo
end

EnforcedStyleAlignWith: def

# bad

private def foo
            end

# good

private def foo
        end

可配置属性

名称 默认值 可配置值

EnforcedStyleAlignWith

start_of_line

start_of_line, def

严重性

警告

字符串

Layout/DotPosition

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查多行方法调用中的 . 位置。

示例

EnforcedStyle: leading (默认)

# bad
something.
  method

# good
something
  .method

EnforcedStyle: trailing

# bad
something
  .method

# good
something.
  method

可配置属性

名称 默认值 可配置值

EnforcedStyle

leading

leading, trailing

参考资料

Layout/ElseAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 else 关键字的对齐方式。通常它们应该与 if/unless/while/until/begin/def/rescue 关键字对齐，但有一些特殊情况，它们应该遵循与 end 对齐方式相同的规则。

示例

# bad
if something
  code
 else
  code
end

# bad
if something
  code
 elsif something
  code
end

# good
if something
  code
else
  code
end

Layout/EmptyComment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

仅限命令行

0.53

1.61

检查空注释。

示例

# bad

#
class Foo
end

# good

#
# Description of `Foo` class.
#
class Foo
end

AllowBorderComment: true（默认）

# good

def foo
end

#################

def bar
end

AllowBorderComment: false

# bad

def foo
end

#################

def bar
end

AllowMarginComment: true（默认）

# good

#
# Description of `Foo` class.
#
class Foo
end

AllowMarginComment: false

# bad

#
# Description of `Foo` class.
#
class Foo
end

可配置属性

名称 默认值 可配置值

AllowBorderComment

true

布尔值

AllowMarginComment

true

布尔值

Layout/EmptyLineAfterGuardClause

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.56

0.59

强制在保护子句后使用空行。

此 cop 允许在保护子句后使用 # :nocov: 指令，因为 SimpleCov 通过将其包装在 # :nocov: 中来从覆盖率报告中排除代码。

def foo
  # :nocov:
  return if condition
  # :nocov:
  bar
end

有关更多详细信息，请参阅 SimpleCov 的文档：https://github.com/simplecov-ruby/simplecov#ignoringskipping-code

示例

# bad
def foo
  return if need_return?
  bar
end

# good
def foo
  return if need_return?

  bar
end

# good
def foo
  return if something?
  return if something_different?

  bar
end

# also good
def foo
  if something?
    do_something
    return if need_return?
  end
end

Layout/EmptyLineAfterMagicComment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查最终魔术注释后的换行符。

示例

# good
# frozen_string_literal: true

# Some documentation for Person
class Person
  # Some code
end

# bad
# frozen_string_literal: true
# Some documentation for Person
class Person
  # Some code
end

参考资料

Layout/EmptyLineAfterMultilineCondition

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.90

-

强制在多行条件后使用空行。

示例

# bad
if multiline &&
  condition
  do_something
end

# good
if multiline &&
  condition

  do_something
end

# bad
case x
when foo,
  bar
  do_something
end

# good
case x
when foo,
  bar

  do_something
end

# bad
begin
  do_something
rescue FooError,
  BarError
  handle_error
end

# good
begin
  do_something
rescue FooError,
  BarError

  handle_error
end

参考资料

Layout/EmptyLineBetweenDefs

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.23

检查类/模块/方法定义之间是否用一个或多个空行隔开。

NumberOfEmptyLines 可以是整数（默认值为 1）或数组（例如 [1, 2]），以指定允许的空行数的最小值和最大值。

AllowAdjacentOneLineDefs 配置是否将相邻的一行定义视为违规。

示例

EmptyLineBetweenMethodDefs: true（默认）

# checks for empty lines between method definitions.

# bad
def a
end
def b
end
# good
def a
end

def b
end

EmptyLineBetweenClassDefs: true（默认）

# checks for empty lines between class definitions.

# bad
class A
end
class B
end
def b
end
# good
class A
end

class B
end

def b
end

EmptyLineBetweenModuleDefs: true（默认）

# checks for empty lines between module definitions.

# bad
module A
end
module B
end
def b
end
# good
module A
end

module B
end

def b
end

AllowAdjacentOneLineDefs: true（默认）

# good
class ErrorA < BaseError; end
class ErrorB < BaseError; end
class ErrorC < BaseError; end

# good
class ErrorA < BaseError; end

class ErrorB < BaseError; end

class ErrorC < BaseError; end

AllowAdjacentOneLineDefs: false

# bad
class ErrorA < BaseError; end
class ErrorB < BaseError; end
class ErrorC < BaseError; end

# good
class ErrorA < BaseError; end

class ErrorB < BaseError; end

class ErrorC < BaseError; end

可配置属性

名称 默认值 可配置值

EmptyLineBetweenMethodDefs

true

布尔值

EmptyLineBetweenClassDefs

true

布尔值

EmptyLineBetweenModuleDefs

true

布尔值

DefLikeMacros

[]

数组

AllowAdjacentOneLineDefs

true

布尔值

NumberOfEmptyLines

1

整数

参考资料

Layout/EmptyLines

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查两个或更多连续的空行。

示例

# bad - It has two empty lines.
some_method
# one empty line
# two empty lines
some_method

# good
some_method
# one empty line
some_method

参考资料

Layout/EmptyLinesAroundAccessModifier

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

访问修饰符应该用空行包围。

示例

EnforcedStyle: around (默认)

# bad
class Foo
  def bar; end
  private
  def baz; end
end

# good
class Foo
  def bar; end

  private

  def baz; end
end

EnforcedStyle: only_before

# bad
class Foo
  def bar; end
  private
  def baz; end
end

# good
class Foo
  def bar; end

  private
  def baz; end
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

around

around, only_before

参考资料

Layout/EmptyLinesAroundArguments

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.52

-

检查方法调用参数周围是否存在空行。

示例

# bad
do_something(
  foo

)

process(bar,

        baz: qux,
        thud: fred)

some_method(

  [1,2,3],
  x: y
)

# good
do_something(
  foo
)

process(bar,
        baz: qux,
        thud: fred)

some_method(
  [1,2,3],
  x: y
)

Layout/EmptyLinesAroundAttributeAccessor

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.83

0.84

检查属性访问器或一组属性访问器之后是否有换行符。默认情况下允许alias语法和alias_method、public、protected和private方法。这些可以通过AllowAliasSyntax和AllowedMethods选项进行自定义。

示例

# bad
attr_accessor :foo
def do_something
end

# good
attr_accessor :foo

def do_something
end

# good
attr_accessor :foo
attr_reader :bar
attr_writer :baz
attr :qux

def do_something
end

AllowAliasSyntax: true (默认)

# good
attr_accessor :foo
alias :foo? :foo

def do_something
end

AllowAliasSyntax: false

# bad
attr_accessor :foo
alias :foo? :foo

def do_something
end

# good
attr_accessor :foo

alias :foo? :foo

def do_something
end

AllowedMethods: ['private']

# good
attr_accessor :foo
private :foo

def do_something
end

可配置属性

名称 默认值 可配置值

AllowAliasSyntax

true

布尔值

AllowedMethods

alias_method, public, protected, private

数组

参考资料

Layout/EmptyLinesAroundBeginBody

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查begin-end块体周围是否存在空行。

示例

# good

begin
  # ...
end

# bad

begin

  # ...

end

参考资料

Layout/EmptyLinesAroundBlockBody

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查块体周围的空行是否符合配置。

示例

EnforcedStyle: no_empty_lines（默认）

# good

foo do |bar|
  # ...
end

EnforcedStyle: empty_lines

# good

foo do |bar|

  # ...

end

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_empty_lines

empty_lines, no_empty_lines

参考

Layout/EmptyLinesAroundClassBody

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.53

检查类体周围的空行是否符合配置。

示例

EnforcedStyle: no_empty_lines（默认）

# good

class Foo
  def bar
    # ...
  end
end

EnforcedStyle: empty_lines

# good

class Foo

  def bar
    # ...
  end

end

EnforcedStyle: empty_lines_except_namespace

# good

class Foo
  class Bar

    # ...

  end
end

EnforcedStyle: empty_lines_special

# good
class Foo

  def bar; end

end

EnforcedStyle: beginning_only

# good

class Foo

  def bar
    # ...
  end
end

EnforcedStyle: ending_only

# good

class Foo
  def bar
    # ...
  end

end

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_empty_lines

empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines, beginning_only, ending_only

参考

Layout/EmptyLinesAroundExceptionHandlingKeywords

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查begin部分体周围是否存在空行。此 cop 不检查begin体开头/结尾和方法定义体周围的空行。Style/EmptyLinesAroundBeginBody或Style/EmptyLinesAroundMethodBody可用于此目的。

示例

# good

begin
  do_something
rescue
  do_something2
else
  do_something3
ensure
  do_something4
end

# good

def foo
  do_something
rescue
  do_something2
end

# bad

begin
  do_something

rescue

  do_something2

else

  do_something3

ensure

  do_something4
end

# bad

def foo
  do_something

rescue

  do_something2
end

参考

Layout/EmptyLinesAroundMethodBody

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查方法体周围是否存在空行。

示例

# good

def foo
  # ...
end

# bad

def bar

  # ...

end

参考

Layout/EmptyLinesAroundModuleBody

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查模块体周围的空行是否符合配置。

示例

EnforcedStyle: no_empty_lines（默认）

# good

module Foo
  def bar
    # ...
  end
end

EnforcedStyle: empty_lines

# good

module Foo

  def bar
    # ...
  end

end

EnforcedStyle: empty_lines_except_namespace

# good

module Foo
  module Bar

    # ...

  end
end

EnforcedStyle: empty_lines_special

# good
module Foo

  def bar; end

end

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_empty_lines

empty_lines, empty_lines_except_namespace, empty_lines_special, no_empty_lines

参考资料

布局/结束对齐

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.53

-

检查结束关键字是否正确对齐。

通过 EnforcedStyleAlignWith 配置参数支持三种模式

如果设置为 keyword（默认值），则 end 应与关键字的开头对齐（例如，if、class 等）。

如果设置为 variable，则 end 应与变量赋值的左侧对齐，如果有的话。

如果设置为 start_of_line，则 end 应与匹配关键字出现的行的开头对齐。

此 Layout/EndAlignment 规则默认情况下与关键字（例如 if、while、case）对齐。另一方面，Layout/BeginEndAlignment 规则默认情况下与 EnforcedStyleAlignWith: start_of_line 对齐，因为 ||= begin 倾向于与行的开头对齐。Layout/DefEndAlignment 规则默认情况下也与 EnforcedStyleAlignWith: start_of_line 对齐。这些样式可以通过每个规则进行配置。

示例

EnforcedStyleAlignWith: keyword（默认）

# bad

variable = if true
    end

# good

variable = if true
           end

variable =
  if true
  end

EnforcedStyleAlignWith: variable

# bad

variable = if true
    end

# good

variable = if true
end

variable =
  if true
  end

EnforcedStyleAlignWith: start_of_line

# bad

variable = if true
    end

puts(if true
     end)

# good

variable = if true
end

puts(if true
end)

variable =
  if true
  end

可配置属性

名称 默认值 可配置值

EnforcedStyleAlignWith

keyword

keyword, variable, start_of_line

严重性

警告

字符串

布局/行尾

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

否

0.49

-

检查源代码中是否存在 Windows 风格的行尾。

示例

EnforcedStyle: native（默认）

# The `native` style means that CR+LF (Carriage Return + Line Feed) is
# enforced on Windows, and LF is enforced on other platforms.

# bad
puts 'Hello' # Return character is LF on Windows.
puts 'Hello' # Return character is CR+LF on other than Windows.

# good
puts 'Hello' # Return character is CR+LF on Windows.
puts 'Hello' # Return character is LF on other than Windows.

EnforcedStyle: lf

# The `lf` style means that LF (Line Feed) is enforced on
# all platforms.

# bad
puts 'Hello' # Return character is CR+LF on all platforms.

# good
puts 'Hello' # Return character is LF on all platforms.

EnforcedStyle: crlf

# The `crlf` style means that CR+LF (Carriage Return + Line Feed) is
# enforced on all platforms.

# bad
puts 'Hello' # Return character is LF on all platforms.

# good
puts 'Hello' # Return character is CR+LF on all platforms.

可配置属性

名称 默认值 可配置值

EnforcedStyle

native

native, lf, crlf

参考资料

布局/额外空格

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查是否存在额外/不必要的空格。

示例

# good if AllowForAlignment is true
name      = "RuboCop"
# Some comment and an empty line

website  += "/rubocop/rubocop" unless cond
puts        "rubocop"          if     debug

# bad for any configuration
set_app("RuboCop")
website  = "https://github.com/rubocop/rubocop"

# good only if AllowBeforeTrailingComments is true
object.method(arg)  # this is a comment

# good even if AllowBeforeTrailingComments is false or not set
object.method(arg) # this is a comment

# good with either AllowBeforeTrailingComments or AllowForAlignment
object.method(arg)         # this is a comment
another_object.method(arg) # this is another comment
some_object.method(arg)    # this is some comment

可配置属性

名称 默认值 可配置值

AllowForAlignment

true

布尔值

AllowBeforeTrailingComments

false

布尔值

ForceEqualSignAlignment

false

布尔值

Layout/FirstArgumentIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.68

0.77

检查方法调用中第一个参数的缩进。第一个参数之后的参数由 Layout/ArgumentAlignment 检查，而不是由这个 cop 检查。

要缩进方法 *定义* 的第一个参数，请查看 Layout/FirstParameterIndentation。

这个 cop 将尊重 Layout/ArgumentAlignment，并且当 Layout/ArgumentAlignment 指定 EnforcedStyle: with_fixed_indentation 时将不起作用。

示例

# bad
some_method(
first_param,
second_param)

foo = some_method(
first_param,
second_param)

foo = some_method(nested_call(
nested_first_param),
second_param)

foo = some_method(
nested_call(
nested_first_param),
second_param)

some_method nested_call(
nested_first_param),
second_param

EnforcedStyle: special_for_inner_method_call_in_parentheses (默认)

# Same as `special_for_inner_method_call` except that the special rule
# only applies if the outer method call encloses its arguments in
# parentheses.

# good
some_method(
  first_param,
second_param)

foo = some_method(
  first_param,
second_param)

foo = some_method(nested_call(
                    nested_first_param),
second_param)

foo = some_method(
  nested_call(
    nested_first_param),
second_param)

some_method nested_call(
  nested_first_param),
second_param

EnforcedStyle: consistent

# The first argument should always be indented one step more than the
# preceding line.

# good
some_method(
  first_param,
second_param)

foo = some_method(
  first_param,
second_param)

foo = some_method(nested_call(
  nested_first_param),
second_param)

foo = some_method(
  nested_call(
    nested_first_param),
second_param)

some_method nested_call(
  nested_first_param),
second_param

EnforcedStyle: consistent_relative_to_receiver

# The first argument should always be indented one level relative to
# the parent that is receiving the argument

# good
some_method(
  first_param,
second_param)

foo = some_method(
        first_param,
second_param)

foo = some_method(nested_call(
                    nested_first_param),
second_param)

foo = some_method(
        nested_call(
          nested_first_param),
second_param)

some_method nested_call(
              nested_first_param),
second_params

EnforcedStyle: special_for_inner_method_call

# The first argument should normally be indented one step more than
# the preceding line, but if it's a argument for a method call that
# is itself a argument in a method call, then the inner argument
# should be indented relative to the inner method.

# good
some_method(
  first_param,
second_param)

foo = some_method(
  first_param,
second_param)

foo = some_method(nested_call(
                    nested_first_param),
second_param)

foo = some_method(
  nested_call(
    nested_first_param),
second_param)

some_method nested_call(
              nested_first_param),
second_param

可配置属性

名称 默认值 可配置值

EnforcedStyle

special_for_inner_method_call_in_parentheses

consistent, consistent_relative_to_receiver, special_for_inner_method_call, special_for_inner_method_call_in_parentheses

IndentationWidth

<none>

整数

Layout/FirstArrayElementIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.68

0.77

检查数组字面量中第一个元素的缩进，其中左括号和第一个元素在不同的行上。其他元素的缩进由 Layout/ArrayAlignment cop 处理。

这个 cop 将尊重 Layout/ArrayAlignment，并且当 Layout/ArrayAlignment 指定 EnforcedStyle: with_fixed_indentation 时将不起作用。

默认情况下，在带括号的方法调用中作为参数的数组字面量，以及数组的左方括号与方法调用的左括号在同一行上的数组字面量，其第一个元素应缩进比左括号内的位置多一步（两个空格）。

其他数组字面量应将其第一个元素缩进比左方括号所在行的开头多一步。

此默认样式称为“special_inside_parentheses”。其他样式是“consistent”和“align_brackets”。以下是示例

示例

EnforcedStyle: special_inside_parentheses (默认)

# The `special_inside_parentheses` style enforces that the first
# element in an array literal where the opening bracket and first
# element are on separate lines is indented one step (two spaces) more
# than the position inside the opening parenthesis.

# bad
array = [
  :value
]
and_in_a_method_call([
  :no_difference
                     ])

# good
array = [
  :value
]
but_in_a_method_call([
                       :its_like_this
                     ])

EnforcedStyle: consistent

# The `consistent` style enforces that the first element in an array
# literal where the opening bracket and the first element are on
# separate lines is indented the same as an array literal which is not
# defined inside a method call.

# bad
# consistent
array = [
  :value
]
but_in_a_method_call([
                       :its_like_this
])

# good
array = [
  :value
]
and_in_a_method_call([
  :no_difference
])

EnforcedStyle: align_brackets

# The `align_brackets` style enforces that the opening and closing
# brackets are indented to the same position.

# bad
# align_brackets
and_now_for_something = [
                          :completely_different
]

# good
# align_brackets
and_now_for_something = [
                          :completely_different
                        ]

可配置属性

名称 默认值 可配置值

EnforcedStyle

special_inside_parentheses

special_inside_parentheses, consistent, align_brackets

IndentationWidth

<none>

整数

Layout/FirstArrayElementLineBreak

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.49

-

检查多行数组中第一个元素之前的换行符。

示例

# bad
[ :a,
  :b]

# good
[
  :a,
  :b]

# good
[:a, :b]

AllowMultilineFinalElement: false（默认）

# bad
[ :a, {
  :b => :c
}]

# good
[
  :a, {
  :b => :c
}]

AllowMultilineFinalElement: true

# good
[:a, {
  :b => :c
}]

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/FirstHashElementIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.68

0.77

检查在哈希文字中第一个键的缩进，其中开括号和第一个键位于不同的行上。其他键的缩进由 HashAlignment cop 处理。

默认情况下，在带括号的方法调用中作为参数的哈希文字，以及哈希的开括号与方法调用的开括号位于同一行的哈希文字，其第一个键的缩进应比开括号内的位置多一步（两个空格）。

其他哈希文字的第一个键的缩进应比开括号所在行的开头多一步。

此默认样式称为“special_inside_parentheses”。其他样式包括“consistent”和“align_braces”。以下是一些示例

示例

EnforcedStyle: special_inside_parentheses（默认）

# The `special_inside_parentheses` style enforces that the first key
# in a hash literal where the opening brace and the first key are on
# separate lines is indented one step (two spaces) more than the
# position inside the opening parentheses.

# bad
hash = {
  key: :value
}
and_in_a_method_call({
  no: :difference
                     })
takes_multi_pairs_hash(x: {
  a: 1,
  b: 2
},
                       y: {
                         c: 1,
                         d: 2
                       })

# good
special_inside_parentheses
hash = {
  key: :value
}
but_in_a_method_call({
                       its_like: :this
                     })
takes_multi_pairs_hash(x: {
                         a: 1,
                         b: 2
                       },
                       y: {
                         c: 1,
                         d: 2
                       })

EnforcedStyle: consistent

# The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# separate lines is indented the same as a hash literal which is not
# defined inside a method call.

# bad
hash = {
  key: :value
}
but_in_a_method_call({
                       its_like: :this
                      })

# good
hash = {
  key: :value
}
and_in_a_method_call({
  no: :difference
})

EnforcedStyle: align_braces

# The `align_brackets` style enforces that the opening and closing
# braces are indented to the same position.

# bad
and_now_for_something = {
                          completely: :different
}
takes_multi_pairs_hash(x: {
  a: 1,
  b: 2
},
                        y: {
                             c: 1,
                             d: 2
                           })

# good
and_now_for_something = {
                          completely: :different
                        }
takes_multi_pairs_hash(x: {
                            a: 1,
                            b: 2
                          },
                       y: {
                            c: 1,
                            d: 2
                          })

可配置属性

名称 默认值 可配置值

EnforcedStyle

special_inside_parentheses

special_inside_parentheses, consistent, align_braces

IndentationWidth

<none>

整数

Layout/FirstHashElementLineBreak

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.49

-

检查多行哈希中第一个元素之前的换行符。

示例

# bad
{ a: 1,
  b: 2}

# good
{
  a: 1,
  b: 2 }

# good
{
  a: 1, b: {
  c: 3
}}

AllowMultilineFinalElement: false（默认）

# bad
{ a: 1, b: {
  c: 3
}}

AllowMultilineFinalElement: true

# bad
{ a: 1,
  b: {
  c: 3
}}

# good
{ a: 1, b: {
  c: 3
}}

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/FirstMethodArgumentLineBreak

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.49

-

检查多行方法调用中第一个参数之前的换行符。

示例

# bad
method(foo, bar,
  baz)

# good
method(
  foo, bar,
  baz)

  # ignored
  method foo, bar,
    baz

AllowMultilineFinalElement: false (默认)

# bad
method(foo, bar, {
  baz: "a",
  qux: "b",
})

# good
method(
  foo, bar, {
  baz: "a",
  qux: "b",
})

AllowMultilineFinalElement: true

# bad
method(foo,
  bar,
  {
    baz: "a",
    qux: "b",
  }
)

# good
method(foo, bar, {
  baz: "a",
  qux: "b",
})

# good
method(
  foo,
  bar,
  {
    baz: "a",
    qux: "b",
  }
)

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/FirstMethodParameterLineBreak

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.49

-

检查多行方法参数定义中第一个参数之前的换行符。

示例

# bad
def method(foo, bar,
    baz)
  do_something
end

# good
def method(
    foo, bar,
    baz)
  do_something
end

# ignored
def method foo,
    bar
  do_something
end

AllowMultilineFinalElement: false (默认)

# bad
def method(foo, bar, baz = {
  :a => "b",
})
  do_something
end

# good
def method(
  foo, bar, baz = {
  :a => "b",
})
  do_something
end

AllowMultilineFinalElement: true

# good
def method(foo, bar, baz = {
  :a => "b",
})
  do_something
end

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/FirstParameterIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.77

检查方法定义中第一个参数的缩进。第一个参数之后的参数由 Layout/ParameterAlignment 检查，而不是由此 cop 检查。

要缩进方法调用的第一个参数，请查看 Layout/FirstArgumentIndentation，它支持与方法定义无关的嵌套选项。

示例

# bad
def some_method(
first_param,
second_param)
  123
end

EnforcedStyle: consistent (默认)

# The first parameter should always be indented one step more than the
# preceding line.

# good
def some_method(
  first_param,
second_param)
  123
end

EnforcedStyle: align_parentheses

# The first parameter should always be indented one step more than the
# opening parenthesis.

# good
def some_method(
                 first_param,
second_param)
  123
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

consistent

consistent, align_parentheses

IndentationWidth

<none>

整数

Layout/HashAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.16

检查多行哈希文字的键、分隔符和值是否根据配置对齐。配置选项是

  • key (左对齐键，哈希火箭和值之前有一个空格)

  • separator (对齐哈希火箭和冒号，右对齐键)

  • table (左对齐键、哈希火箭和值)

还可以配置作为方法调用最后一个参数传递的哈希的处理方式。选项是

  • always_inspect

  • always_ignore

  • ignore_implicit (没有花括号)

或者，您可以指定多个允许的样式。这可以通过将样式列表传递给 EnforcedStyles 来完成。

示例

EnforcedHashRocketStyle: key (默认)

# bad
{
  :foo => bar,
   :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

# good
{
  :foo => bar,
  :ba => baz
}

EnforcedHashRocketStyle: separator

# bad
{
  :foo => bar,
  :ba => baz
}
{
  :foo => bar,
  :ba  => baz
}

# good
{
  :foo => bar,
   :ba => baz
}

EnforcedHashRocketStyle: table

# bad
{
  :foo => bar,
   :ba => baz
}

# good
{
  :foo => bar,
  :ba  => baz
}

EnforcedColonStyle: key (默认)

# bad
{
  foo: bar,
   ba: baz
}
{
  foo: bar,
  ba:  baz
}

# good
{
  foo: bar,
  ba: baz
}

EnforcedColonStyle: separator

# bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
   ba: baz
}

EnforcedColonStyle: table

# bad
{
  foo: bar,
  ba: baz
}

# good
{
  foo: bar,
  ba:  baz
}

EnforcedLastArgumentHashStyle: always_inspect (默认)

# Inspect both implicit and explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
             bar: 2)

# good
do_something(
  foo: 1,
  bar: 2
)

# good
do_something({foo: 1,
              bar: 2})

# good
do_something({
  foo: 1,
  bar: 2
})

EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.

# good
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.

# bad
do_something({foo: 1,
  bar: 2})

# good
do_something(foo: 1,
  bar: 2)

EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.

# bad
do_something(foo: 1,
  bar: 2)

# good
do_something({foo: 1,
  bar: 2})

可配置属性

名称 默认值 可配置值

EnforcedHashRocketStyle

key

key, separator, table

EnforcedColonStyle

key

key, separator, table

强制最后一个参数哈希样式

always_inspect

always_inspect, always_ignore, ignore_implicit, ignore_explicit

Layout/HeredocArgumentClosingParenthesis

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.68

-

检查在将 HEREDOC 字符串作为参数传递给方法调用时，闭合括号的位置。它应该放在包含打开 HEREDOC 标签的行末尾。

示例

# bad

   foo(<<-SQL
     bar
   SQL
   )

   foo(<<-SQL, 123, <<-NOSQL,
     bar
   SQL
     baz
   NOSQL
   )

   foo(
     bar(<<-SQL
       baz
     SQL
     ),
     123,
   )

# good

   foo(<<-SQL)
     bar
   SQL

   foo(<<-SQL, 123, <<-NOSQL)
     bar
   SQL
     baz
   NOSQL

   foo(
     bar(<<-SQL),
       baz
     SQL
     123,
   )

参考

Layout/HeredocIndentation

必需的 Ruby 版本：2.3
默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.85

检查 here document 主体的缩进。主体缩进一个步骤。

注意：当 Layout/LineLength 的 AllowHeredoc 为 false（非默认值）时，此 cop 不会为长 here document 添加任何违规，以避免 Layout/LineLength 的违规。

示例

# bad
<<-RUBY
something
RUBY

# good
<<~RUBY
  something
RUBY

参考

Layout/IndentationConsistency

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查不一致的缩进。

indented_internal_methods 和 normal 之间的区别在于，indented_internal_methods 样式规定，在类和模块中，protected 和 private 修饰符关键字应与公共方法缩进相同，并且受保护和私有成员应比修饰符缩进一个步骤。除此之外，两种样式都意味着相同逻辑深度的实体应具有相同的缩进。

示例

强制样式：normal（默认）

# bad
class A
  def test
    puts 'hello'
     puts 'world'
  end
end

# bad
class A
  def test
    puts 'hello'
    puts 'world'
  end

  protected

    def foo
    end

  private

    def bar
    end
end

# good
class A
  def test
    puts 'hello'
    puts 'world'
  end
end

# good
class A
  def test
    puts 'hello'
    puts 'world'
  end

  protected

  def foo
  end

  private

  def bar
  end
end

强制样式：indented_internal_methods

# bad
class A
  def test
    puts 'hello'
     puts 'world'
  end
end

# bad
class A
  def test
    puts 'hello'
    puts 'world'
  end

  protected

  def foo
  end

  private

  def bar
  end
end

# good
class A
  def test
    puts 'hello'
    puts 'world'
  end
end

# good
class A
  def test
    puts 'hello'
    puts 'world'
  end

  protected

    def foo
    end

  private

    def bar
    end
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

normal

normal, indented_internal_methods

参考

Layout/IndentationStyle

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.82

检查缩进方法是否一致。缩进仅使用制表符或仅使用空格。

示例

强制样式：spaces（默认）

# bad
# This example uses a tab to indent bar.
def foo
  bar
end

# good
# This example uses spaces to indent bar.
def foo
  bar
end

强制样式：tabs

# bad
# This example uses spaces to indent bar.
def foo
  bar
end

# good
# This example uses a tab to indent bar.
def foo
  bar
end

可配置属性

名称 默认值 可配置值

IndentationWidth

<none>

整数

EnforcedStyle

spaces

spaces, tabs

参考资料

Layout/IndentationWidth

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查缩进是否使用指定的空格数。

另请参阅 IndentationConsistency 规则，它是此规则的补充。

示例

# bad
class A
 def test
  puts 'hello'
 end
end

# good
class A
  def test
    puts 'hello'
  end
end

AllowedPatterns: ['^\s*module']

# bad
module A
class B
  def test
  puts 'hello'
  end
end
end

# good
module A
class B
  def test
    puts 'hello'
  end
end
end

可配置属性

名称 默认值 可配置值

Width

2

整数

AllowedPatterns

[]

数组

参考资料

Layout/InitialIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查文件中第一个非空白非注释行的缩进。

示例

# bad
   class A
     def foo; end
   end

# good
class A
  def foo; end
end

Layout/LeadingCommentSpace

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.73

检查注释在 之后是否有前导空格，表示注释的开始。对于某些 RDoc 特殊语法，例如 ++、--、:nodoc、=begin 和 =end 注释、"shebang" 指令或 rackup 选项，不需要前导空格。

示例

# bad
#Some comment

# good
# Some comment

AllowDoxygenCommentStyle: false（默认）

# bad

#**
# Some comment
# Another line of comment
#*

AllowDoxygenCommentStyle: true

# good

#**
# Some comment
# Another line of comment
#*

AllowGemfileRubyComment: false（默认）

# bad

#ruby=2.7.0
#ruby-gemset=myproject

AllowGemfileRubyComment: true

# good

#ruby=2.7.0
#ruby-gemset=myproject

可配置属性

名称 默认值 可配置值

AllowDoxygenCommentStyle

false

布尔值

AllowGemfileRubyComment

false

布尔值

参考资料

Layout/LeadingEmptyLines

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.57

0.77

检查文件开头是否有不必要的空白行。

示例

# bad
# (start of file)

class Foo
end

# bad
# (start of file)

# a comment

# good
# (start of file)
class Foo
end

# good
# (start of file)
# a comment

Layout/LineContinuationLeadingSpace

默认启用 安全 支持自动更正 添加版本 更改版本

待定

是

始终

1.31

1.45

检查跨多行（通过反斜杠）的字符串是否包含尾随空格而不是前导空格（默认）或前导空格而不是尾随空格。

示例

EnforcedStyle: trailing（默认）

# bad
'this text contains a lot of' \
'               spaces'

# good
'this text contains a lot of               ' \
'spaces'

# bad
'this text is too' \
' long'

# good
'this text is too ' \
'long'

EnforcedStyle: leading

# bad
'this text contains a lot of               ' \
'spaces'

# good
'this text contains a lot of' \
'               spaces'

# bad
'this text is too ' \
'long'

# good
'this text is too' \
' long'

可配置属性

名称 默认值 可配置值

EnforcedStyle

trailing

leading, trailing

Layout/LineContinuationSpacing

默认启用 安全 支持自动更正 添加版本 更改版本

待定

是

始终

1.31

-

检查行延续的反斜杠是否与前面的文本之间恰好隔着一个空格（默认）或零个空格。

示例

EnforcedStyle: space（默认）

# bad
'a'\
'b'  \
'c'

# good
'a' \
'b' \
'c'

EnforcedStyle: no_space

# bad
'a' \
'b'  \
'c'

# good
'a'\
'b'\
'c'

可配置属性

名称 默认值 可配置值

EnforcedStyle

space

space, no_space

Layout/LineEndStringConcatenationIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

待定

是

始终

1.18

-

检查以字符串文字和反斜杠结尾的行后面的下一行的缩进。

如果设置了EnforcedStyle: aligned，则连接的字符串部分应与第一部分对齐。 有一些例外，例如隐式返回值，无论EnforcedStyle配置如何，连接的字符串部分都应缩进。

如果设置了EnforcedStyle: indented，则第二行应比第一行多缩进一步。 第 3 行及以后的行应与第 2 行对齐。

示例

# bad
def some_method
  'x' \
  'y' \
  'z'
end

my_hash = {
  first: 'a message' \
    'in two parts'
}

# good
def some_method
  'x' \
    'y' \
    'z'
end

EnforcedStyle: aligned（默认）

# bad
puts 'x' \
  'y'

my_hash = {
  first: 'a message' \
    'in two parts'
}

# good
puts 'x' \
     'y'

my_hash = {
  first: 'a message' \
         'in two parts'
}

EnforcedStyle: indented

# bad
result = 'x' \
         'y'

my_hash = {
  first: 'a message' \
         'in two parts'
}

# good
result = 'x' \
  'y'

my_hash = {
  first: 'a message' \
    'in two parts'
}

可配置属性

名称 默认值 可配置值

EnforcedStyle

aligned

aligned, indented

IndentationWidth

<none>

整数

Layout/LineLength

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.25

1.4

检查源代码中行的长度。 最大长度是可配置的。 制表符大小在Layout/IndentationStyle cop 的IndentationWidth 中配置。 它还默认忽略 shebang 行。

此 cop 具有某些自动更正功能。 它可以通过在可以安全地跨行拆分的表达式中插入换行符来以编程方式缩短某些长行。 这些包括数组、哈希和带有参数列表的方法调用。

如果启用了自动更正，则建议使用以下 Layout cop 来进一步格式化断开的行。（其中许多默认情况下已启用。）

  • ArgumentAlignment

  • ArrayAlignment

  • BlockAlignment

  • BlockDelimiters

  • BlockEndNewline

  • ClosingParenthesisIndentation

  • FirstArgumentIndentation

  • FirstArrayElementIndentation

  • FirstHashElementIndentation

  • FirstParameterIndentation

  • HashAlignment

  • IndentationWidth

  • MultilineArrayLineBreaks

  • MultilineBlockLayout

  • MultilineHashBraceLayout

  • MultilineHashKeyLineBreaks

  • MultilineMethodArgumentLineBreaks

  • MultilineMethodParameterLineBreaks

  • ParameterAlignment

这些 cop 共同将格式化哈希、数组、方法调用等。 例如，假设最大列数为 25

示例

# bad
{foo: "0000000000", bar: "0000000000", baz: "0000000000"}

# good
{foo: "0000000000",
bar: "0000000000", baz: "0000000000"}

# good (with recommended cops enabled)
{
  foo: "0000000000",
  bar: "0000000000",
  baz: "0000000000",
}

可配置属性

名称 默认值 可配置值

最大行长

120

整数

允许 Heredoc

true

布尔值

允许 URI

true

布尔值

URI 方案

http, https

数组

忽略 Cop 指令

true

布尔值

AllowedPatterns

[]

数组

参考

Layout/MultilineArrayBraceLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查数组字面量的结束大括号是否在与最后一个数组元素相同的行上或新行上。

使用 symmetrical（默认）样式时

如果数组的开始大括号与数组的第一个元素在同一行上，则结束大括号应与数组的最后一个元素在同一行上。

如果数组的开始大括号在第一个元素的上一行，则结束大括号应在最后一个元素的下一行。

使用 new_line 样式时

多行数组字面量的结束大括号必须在数组最后一个元素的下一行。

使用 same_line 样式时

多行数组字面量的结束大括号必须与最后一个数组元素在同一行。

示例

EnforcedStyle: symmetrical（默认）

# bad
[ :a,
  :b
]

# bad
[
  :a,
  :b ]

# good
[ :a,
  :b ]

# good
[
  :a,
  :b
]

EnforcedStyle: new_line

# bad
[
  :a,
  :b ]

# bad
[ :a,
  :b ]

# good
[ :a,
  :b
]

# good
[
  :a,
  :b
]

EnforcedStyle: same_line

# bad
[ :a,
  :b
]

# bad
[
  :a,
  :b
]

# good
[
  :a,
  :b ]

# good
[ :a,
  :b ]

可配置属性

名称 默认值 可配置值

EnforcedStyle

对称

symmetrical, new_line, same_line

Layout/MultilineArrayLineBreaks

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.67

-

确保多行数组中的每个项目都从单独的行开始。

示例

# bad
[
  a, b,
  c
]

# good
[
  a,
  b,
  c
]

# good
[
  a,
  b,
  foo(
    bar
  )
]

AllowMultilineFinalElement: false（默认）

# bad
[a, b, foo(
  bar
)]

AllowMultilineFinalElement: true

# good
[a, b, foo(
  bar
)]

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/MultilineAssignmentLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.49

-

检查多行赋值在赋值运算符之后是否有换行符。

示例

EnforcedStyle: new_line（默认）

# bad
foo = if expression
  'bar'
end

# good
foo =
  if expression
    'bar'
  end

# good
foo =
  begin
    compute
  rescue => e
    nil
  end

EnforcedStyle: same_line

# good
foo = if expression
  'bar'
end

SupportedTypes: ['block', 'case', 'class', 'if', 'kwbegin', 'module']（默认）

# good
foo =
  if expression
    'bar'
  end

# good
foo =
  [1].map do |i|
    i + 1
  end

SupportedTypes: ['block']

# good
foo = if expression
  'bar'
end

# good
foo =
  [1].map do |i|
    'bar' * i
  end

可配置属性

名称 默认值 可配置值

EnforcedStyle

新线

same_line, new_line

参考

Layout/MultilineBlockLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查多行 do end 块的起始行之后是否包含换行符。此外，它还会检查块参数（如果有）是否与块的起始行位于同一行。如果将块参数放在单独的行上，因为整行否则会太长，则可以接受。

示例

# bad
blah do |i| foo(i)
  bar(i)
end

# bad
blah do
  |i| foo(i)
  bar(i)
end

# good
blah do |i|
  foo(i)
  bar(i)
end

# bad
blah { |i| foo(i)
  bar(i)
}

# good
blah { |i|
  foo(i)
  bar(i)
}

# good
blah { |
  long_list,
  of_parameters,
  that_would_not,
  fit_on_one_line
|
  foo(i)
  bar(i)
}

Layout/MultilineHashBraceLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查哈希文字中的结束大括号是否与最后一个哈希元素位于同一行，或者位于新行。

使用 symmetrical（默认）样式时

如果哈希的开始大括号与哈希的第一个元素位于同一行，则结束大括号应与哈希的最后一个元素位于同一行。

如果哈希的开始大括号位于第一个元素的上一行，则结束大括号应位于最后一个元素的下一行。

使用 new_line 样式时

多行哈希文字的结束大括号必须位于哈希最后一个元素的下一行。

使用 same_line 样式时

多行哈希文字的结束大括号必须与哈希最后一个元素位于同一行。

示例

EnforcedStyle: symmetrical (默认)

# bad
{ a: 1,
  b: 2
}
# bad
{
  a: 1,
  b: 2 }

# good
{ a: 1,
  b: 2 }

# good
{
  a: 1,
  b: 2
}

EnforcedStyle: new_line

# bad
{
  a: 1,
  b: 2 }

# bad
{ a: 1,
  b: 2 }

# good
{ a: 1,
  b: 2
}

# good
{
  a: 1,
  b: 2
}

EnforcedStyle: same_line

# bad
{ a: 1,
  b: 2
}

# bad
{
  a: 1,
  b: 2
}

# good
{
  a: 1,
  b: 2 }

# good
{ a: 1,
  b: 2 }

可配置属性

名称 默认值 可配置值

EnforcedStyle

对称

symmetrical, new_line, same_line

Layout/MultilineHashKeyLineBreaks

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.67

-

确保多行哈希中的每个键都从单独的行开始。

示例

# bad
{
  a: 1, b: 2,
  c: 3
}

# good
{
  a: 1,
  b: 2,
  c: 3
}

# good
{
  a: 1,
  b: {
    c: 3,
  }
}

AllowMultilineFinalElement: false (默认)

# bad
{ a: 1, b: {
  c: 3,
}}

AllowMultilineFinalElement: true

# good
{ a: 1, b: {
  c: 3,
}}

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/MultilineMethodArgumentLineBreaks

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

0.67

-

确保多行方法调用中的每个参数都从单独的行开始。

此 cop 不会移动第一个参数，如果您希望它位于单独的行上，请参阅 Layout/FirstMethodArgumentLineBreak。

示例

# bad
foo(a, b,
  c
)

# bad
foo(a, b, {
  foo: "bar",
})

# good
foo(
  a,
  b,
  c
)

# good
foo(a, b, c)

AllowMultilineFinalElement: false (默认)

# good
foo(
  a,
  b,
  {
    foo: "bar",
  }
)

AllowMultilineFinalElement: true

# good
foo(
  a,
  b,
  {
    foo: "bar",
  }
)

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/MultilineMethodCallBraceLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查方法调用中的闭合大括号是否与最后一个方法参数位于同一行，或位于新行。

使用 symmetrical（默认）样式时

如果方法调用的左大括号与调用的第一个参数位于同一行，则闭合大括号应与调用的最后一个参数位于同一行。

如果方法调用的左大括号位于第一个参数所在行的上一行，则闭合大括号应位于最后一个参数所在行的下一行。

使用 new_line 样式时

多行方法调用的闭合大括号必须位于调用最后一个参数所在行的下一行。

使用 same_line 样式时

多行方法调用的闭合大括号必须与调用最后一个参数位于同一行。

示例

EnforcedStyle: symmetrical（默认）

# bad
foo(a,
  b
)

# bad
foo(
  a,
  b)

# good
foo(a,
  b)

# good
foo(
  a,
  b
)

EnforcedStyle: new_line

# bad
foo(
  a,
  b)

# bad
foo(a,
  b)

# good
foo(a,
  b
)

# good
foo(
  a,
  b
)

EnforcedStyle: same_line

# bad
foo(a,
  b
)

# bad
foo(
  a,
  b
)

# good
foo(
  a,
  b)

# good
foo(a,
  b)

可配置属性

名称 默认值 可配置值

EnforcedStyle

对称

symmetrical, new_line, same_line

Layout/MultilineMethodCallIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查跨越多行的调用方法中方法名称部分的缩进。

示例

EnforcedStyle: aligned（默认）

# bad
while myvariable
.b
  # do something
end

# good
while myvariable
      .b
  # do something
end

# good
Thing.a
     .b
     .c

EnforcedStyle: indented

# good
while myvariable
  .b

  # do something
end

EnforcedStyle: indented_relative_to_receiver

# good
while myvariable
        .a
        .b

  # do something
end

# good
myvariable = Thing
               .a
               .b
               .c

可配置属性

名称 默认值 可配置值

EnforcedStyle

aligned

aligned, indented, indented_relative_to_receiver

IndentationWidth

<none>

整数

Layout/MultilineMethodDefinitionBraceLayout

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查方法定义中的闭合大括号是否与最后一个方法参数位于同一行，或位于新行。

使用 symmetrical（默认）样式时

如果方法定义的左大括号与定义的第一个参数位于同一行，则闭合大括号应与定义的最后一个参数位于同一行。

如果方法定义的左大括号位于第一个参数所在行的上一行，则闭合大括号应位于最后一个参数所在行的下一行。

使用 new_line 样式时

多行方法定义的闭合大括号必须位于定义最后一个参数所在行的下一行。

使用 same_line 样式时

多行方法定义的闭合大括号必须与定义最后一个参数位于同一行。

示例

EnforcedStyle: symmetrical (默认)

# bad
def foo(a,
  b
)
end

# bad
def foo(
  a,
  b)
end

# good
def foo(a,
  b)
end

# good
def foo(
  a,
  b
)
end

EnforcedStyle: new_line

# bad
def foo(
  a,
  b)
end

# bad
def foo(a,
  b)
end

# good
def foo(a,
  b
)
end

# good
def foo(
  a,
  b
)
end

EnforcedStyle: same_line

# bad
def foo(a,
  b
)
end

# bad
def foo(
  a,
  b
)
end

# good
def foo(
  a,
  b)
end

# good
def foo(a,
  b)
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

对称

symmetrical, new_line, same_line

Layout/MultilineMethodParameterLineBreaks

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

1.32

-

确保多行方法定义中的每个参数都从单独的行开始。

此 cop 不会移动第一个参数，如果您希望它在单独的行上，请参见 Layout/FirstMethodParameterLineBreak。

示例

# bad
def foo(a, b,
  c
)
end

# good
def foo(
  a,
  b,
  c
)
end

# good
def foo(
  a,
  b = {
    foo: "bar",
  }
)
end

# good
def foo(a, b, c)
end

AllowMultilineFinalElement: false (默认)

# bad
def foo(a, b = {
  foo: "bar",
})
end

AllowMultilineFinalElement: true

# good
def foo(a, b = {
  foo: "bar",
})
end

可配置属性

名称 默认值 可配置值

AllowMultilineFinalElement

false

布尔值

Layout/MultilineOperationIndentation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查跨越多行的二元运算符中右侧操作数的缩进。

aligned 样式检查运算符是否对齐，如果它们是 if 或 while 条件、显式 return 语句等的一部分。在其他情况下，无论强制样式如何，第二个操作数都应缩进。

示例

EnforcedStyle: aligned (默认)

# bad
if a +
    b
  something &&
  something_else
end

# good
if a +
   b
  something &&
    something_else
end

EnforcedStyle: indented

# bad
if a +
   b
  something &&
  something_else
end

# good
if a +
    b
  something &&
    something_else
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

aligned

aligned, indented

IndentationWidth

<none>

整数

Layout/ParameterAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.77

在这里，我们检查多行方法调用或定义中的参数是否对齐。

要设置第一个参数的对齐方式，请使用 cop FirstParameterIndentation。

示例

EnforcedStyle: with_first_parameter (默认)

# good

def foo(bar,
        baz)
  123
end

def foo(
  bar,
  baz
)
  123
end

# bad

def foo(bar,
     baz)
  123
end

# bad

def foo(
  bar,
     baz)
  123
end

EnforcedStyle: with_fixed_indentation

# good

def foo(bar,
  baz)
  123
end

def foo(
  bar,
  baz
)
  123
end

# bad

def foo(bar,
        baz)
  123
end

# bad

def foo(
  bar,
     baz)
  123
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

with_first_parameter

with_first_parameter, with_fixed_indentation

IndentationWidth

<none>

整数

参考

Layout/RedundantLineBreak

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

1.13

-

检查某些表达式（例如方法调用）是否不必要地被分解成多行，而这些表达式可以完全放在一行上。

示例

任何配置

# bad
foo(
  a,
  b
)

puts 'string that fits on ' \
     'a single line'

things
  .select { |thing| thing.cond? }
  .join('-')

# good
foo(a, b)

puts 'string that fits on a single line'

things.select { |thing| thing.cond? }.join('-')

InspectBlocks: false (默认)

# good
foo(a) do |x|
  puts x
end

InspectBlocks: true

# bad
foo(a) do |x|
  puts x
end

# good
foo(a) { |x| puts x }

可配置属性

名称 默认值 可配置值

InspectBlocks

false

布尔值

Layout/RescueEnsureAlignment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 rescue 和 ensure 关键字是否正确对齐。

示例

# bad
begin
  something
  rescue
  puts 'error'
end

# good
begin
  something
rescue
  puts 'error'
end

Layout/SingleLineBlockChain

默认启用 安全 支持自动更正 添加版本 更改版本

已禁用

是

始终

1.14

-

检查方法调用是否链接到单行块。它认为在点之前换行可以提高代码的可读性。

示例

# bad
example.select { |item| item.cond? }.join('-')

# good
example.select { |item| item.cond? }
       .join('-')

# good (not a concern for this cop)
example.select do |item|
  item.cond?
end.join('-')

Layout/SpaceAfterColon

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查冒号 (:) 后面是否没有空格。注意，此 cop 不处理三元运算符后的空格，这些空格由 Layout/SpaceAroundOperators 处理。

示例

# bad
def f(a:, b:2); {a:3}; end

# good
def f(a:, b: 2); {a: 3}; end

参考资料

Layout/SpaceAfterComma

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查逗号 (,) 后面是否没有空格。

示例

# bad
[1,2]
{ foo:bar,}

# good
[1, 2]
{ foo:bar, }

参考资料

Layout/SpaceAfterMethodName

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 def 中方法名称和左括号之间是否有空格。

示例

# bad
def func (x) end
def method= (y) end

# good
def func(x) end
def method=(y) end

参考资料

Layout/SpaceAfterNot

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 `!` 后面是否有空格。

示例

# bad
! something

# good
!something

参考资料

Layout/SpaceAfterSemicolon

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查分号 (;) 后面是否没有空格。

示例

# bad
x = 1;y = 2

# good
x = 1; y = 2

参考资料

Layout/SpaceAroundBlockParameters

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查块参数管道内和管道后的空格。管道内的换行符由 `Layout/MultilineBlockLayout` 检查，而不是此 cop。

示例

EnforcedStyleInsidePipes: no_space (默认)

# bad
{}.each { | x,  y |puts x }
->( x,  y ) { puts x }

# good
{}.each { |x, y| puts x }
->(x, y) { puts x }

EnforcedStyleInsidePipes: space

# bad
{}.each { |x,  y| puts x }
->(x,  y) { puts x }

# good
{}.each { | x, y | puts x }
->( x, y ) { puts x }

可配置属性

名称 默认值 可配置值

EnforcedStyleInsidePipes

no_space

space, no_space

Layout/SpaceAroundEqualsInParameterDefault

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查参数默认赋值中的等号周围是否有空格，具体取决于配置。

示例

EnforcedStyle: space（默认）

# bad
def some_method(arg1=:default, arg2=nil, arg3=[])
  # do something...
end

# good
def some_method(arg1 = :default, arg2 = nil, arg3 = [])
  # do something...
end

EnforcedStyle: no_space

# bad
def some_method(arg1 = :default, arg2 = nil, arg3 = [])
  # do something...
end

# good
def some_method(arg1=:default, arg2=nil, arg3=[])
  # do something...
end

可配置属性

名称 默认值 可配置值

EnforcedStyle

space

space, no_space

参考

Layout/SpaceAroundKeyword

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查关键字周围的空格。

示例

# bad
something 'test'do|x|
end

while(something)
end

something = 123if test

# good
something 'test' do |x|
end

while (something)
end

something = 123 if test

Layout/SpaceAroundMethodCallOperator

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.82

-

检查方法调用运算符周围没有空格。

示例

# bad
foo. bar
foo .bar
foo . bar
foo. bar .buzz
foo
  . bar
  . buzz
foo&. bar
foo &.bar
foo &. bar
foo &. bar&. buzz
RuboCop:: Cop
RuboCop:: Cop:: Base
:: RuboCop::Cop

# good
foo.bar
foo.bar.buzz
foo
  .bar
  .buzz
foo&.bar
foo&.bar&.buzz
RuboCop::Cop
RuboCop::Cop::Base
::RuboCop::Cop

Layout/SpaceAroundOperators

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查运算符周围是否有空格，除了 **，它应该或不应该有周围的空格，具体取决于配置。它允许在运算符周围进行垂直对齐，包括一个或多个空格。

此 cop 有 AllowForAlignment 选项。当 true 时，允许大多数使用额外的空格，如果目的是与前一行或下一行的运算符对齐，不包括空行或注释行。

示例

# bad
total = 3*4
"apple"+"juice"
my_number = 38/4

# good
total = 3 * 4
"apple" + "juice"
my_number = 38 / 4

AllowForAlignment: true（默认）

# good
{
  1 =>  2,
  11 => 3
}

AllowForAlignment: false

# bad
{
  1 =>  2,
  11 => 3
}

EnforcedStyleForExponentOperator: no_space（默认）

# bad
a ** b

# good
a**b

EnforcedStyleForExponentOperator: space

# bad
a**b

# good
a ** b

EnforcedStyleForRationalLiterals: no_space（默认）

# bad
1 / 48r

# good
1/48r

EnforcedStyleForRationalLiterals: space

# bad
1/48r

# good
1 / 48r

可配置属性

名称 默认值 可配置值

AllowForAlignment

true

布尔值

EnforcedStyleForExponentOperator

no_space

space, no_space

EnforcedStyleForRationalLiterals

no_space

space, no_space

参考

Layout/SpaceBeforeBlockBraces

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.52

检查块括号在开括号之前是否有空格，具体取决于配置。

示例

EnforcedStyle: space（默认）

# bad
foo.map{ |a|
  a.bar.to_s
}

# good
foo.map { |a|
  a.bar.to_s
}

EnforcedStyle: no_space

# bad
foo.map { |a|
  a.bar.to_s
}

# good
foo.map{ |a|
  a.bar.to_s
}

EnforcedStyleForEmptyBraces: space（默认）

# bad
7.times{}

# good
7.times {}

EnforcedStyleForEmptyBraces: no_space

# bad
7.times {}

# good
7.times{}

可配置属性

名称 默认值 可配置值

EnforcedStyle

space

space, no_space

EnforcedStyleForEmptyBraces

space

space, no_space

Layout/SpaceBeforeBrackets

默认启用 安全 支持自动更正 添加版本 更改版本

待定

是

始终

1.7

-

检查接收器名称和左括号之间是否有空格。

示例

# bad
collection [index_or_key]

# good
collection[index_or_key]

参考

Layout/SpaceBeforeComma

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查逗号 (,) 前面是否有空格。

示例

# bad
[1 , 2 , 3]
a(1 , 2)
each { |a , b| }

# good
[1, 2, 3]
a(1, 2)
each { |a, b| }

Layout/SpaceBeforeComment

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查同一行上的标记和注释之间是否缺少空格。

示例

# bad
1 + 1# this operation does ...

# good
1 + 1 # this operation does ...

Layout/SpaceBeforeFirstArg

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查在没有括号的方法调用中，方法名称和第一个参数之间是否使用了一个空格。

或者，如果 AllowForAlignment 配置参数为 true，则可以添加额外的空格以将参数与前一行或后一行的内容对齐。

示例

# bad
something  x
something   y, z
something'hello'

# good
something x
something y, z
something 'hello'

可配置属性

名称 默认值 可配置值

AllowForAlignment

true

布尔值

Layout/SpaceBeforeSemicolon

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查分号 (;) 前面是否有空格。

示例

# bad
x = 1 ; y = 2

# good
x = 1; y = 2

Layout/SpaceInLambdaLiteral

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 lambda 文字中 → 和打开的参数括号 (() 之间是否有空格。

示例

EnforcedStyle: require_no_space (默认)

# bad
a = -> (x, y) { x + y }

# good
a = ->(x, y) { x + y }

EnforcedStyle: require_space

# bad
a = ->(x, y) { x + y }

# good
a = -> (x, y) { x + y }

可配置属性

名称 默认值 可配置值

EnforcedStyle

require_no_space

require_no_space, require_space

Layout/SpaceInsideArrayLiteralBrackets

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.52

-

检查用于数组文字的括号是否根据配置有或没有周围的空格。

示例

EnforcedStyle: no_space (默认)

# The `no_space` style enforces that array literals have
# no surrounding space.

# bad
array = [ a, b, c, d ]

# good
array = [a, b, c, d]

EnforcedStyle: space

# The `space` style enforces that array literals have
# surrounding space.

# bad
array = [a, b, c, d]

# good
array = [ a, b, c, d ]

EnforcedStyle: compact

# The `compact` style normally requires a space inside
# array brackets, with the exception that successive left
# or right brackets are collapsed together in nested arrays.

# bad
array = [ a, [ b, c ] ]
array = [
  [ a ],
  [ b, c ]
]

# good
array = [ a, [ b, c ]]
array = [[ a ],
  [ b, c ]]

EnforcedStyleForEmptyBrackets: no_space (默认)

# The `no_space` EnforcedStyleForEmptyBrackets style enforces that
# empty array brackets do not contain spaces.

# bad
foo = [ ]
bar = [     ]

# good
foo = []
bar = []

EnforcedStyleForEmptyBrackets: space

# The `space` EnforcedStyleForEmptyBrackets style enforces that
# empty array brackets contain exactly one space.

# bad
foo = []
bar = [    ]

# good
foo = [ ]
bar = [ ]

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_space

space, no_space, compact

EnforcedStyleForEmptyBrackets

no_space

space, no_space

Layout/SpaceInsideArrayPercentLiteral

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查数组百分比字面量（例如 %i/%w）中不必要的额外空格。

请注意，空百分比字面量（例如 %i( )）由 Layout/SpaceInsidePercentLiteralDelimiters 检查。

示例

# bad
%w(foo  bar  baz)
# good
%i(foo bar baz)

Layout/SpaceInsideBlockBraces

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查块括号根据配置是否有或没有周围的空格。对于接受参数的块，它会根据配置检查左括号是否有或没有尾随空格。

示例

EnforcedStyle: space（默认）

# The `space` style enforces that block braces have
# surrounding space.

# bad
some_array.each {puts e}

# good
some_array.each { puts e }

EnforcedStyle: no_space

# The `no_space` style enforces that block braces don't
# have surrounding space.

# bad
some_array.each { puts e }

# good
some_array.each {puts e}

EnforcedStyleForEmptyBraces: no_space（默认）

# The `no_space` EnforcedStyleForEmptyBraces style enforces that
# block braces don't have a space in between when empty.

# bad
some_array.each {   }
some_array.each {  }
some_array.each { }

# good
some_array.each {}

EnforcedStyleForEmptyBraces: space

# The `space` EnforcedStyleForEmptyBraces style enforces that
# block braces have at least a space in between when empty.

# bad
some_array.each {}

# good
some_array.each { }
some_array.each {  }
some_array.each {   }

SpaceBeforeBlockParameters: true（默认）

# The SpaceBeforeBlockParameters style set to `true` enforces that
# there is a space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each {|n| n * 2 }

# good
[1, 2, 3].each { |n| n * 2 }

SpaceBeforeBlockParameters: false

# The SpaceBeforeBlockParameters style set to `false` enforces that
# there is no space between `{` and `|`. Overrides `EnforcedStyle`
# if there is a conflict.

# bad
[1, 2, 3].each { |n| n * 2 }

# good
[1, 2, 3].each {|n| n * 2 }

可配置属性

名称 默认值 可配置值

EnforcedStyle

space

space, no_space

EnforcedStyleForEmptyBraces

no_space

space, no_space

SpaceBeforeBlockParameters

true

布尔值

Layout/SpaceInsideHashLiteralBraces

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查用于哈希字面量的括号根据配置是否有或没有周围的空格。

示例

EnforcedStyle: space（默认）

# The `space` style enforces that hash literals have
# surrounding space.

# bad
h = {a: 1, b: 2}

# good
h = { a: 1, b: 2 }

EnforcedStyle: no_space

# The `no_space` style enforces that hash literals have
# no surrounding space.

# bad
h = { a: 1, b: 2 }

# good
h = {a: 1, b: 2}

EnforcedStyle: compact

# The `compact` style normally requires a space inside
# hash braces, with the exception that successive left
# braces or right braces are collapsed together in nested hashes.

# bad
h = { a: { b: 2 } }
foo = { { a: 1 } => { b: { c: 2 } } }

# good
h = { a: { b: 2 }}
foo = {{ a: 1 } => { b: { c: 2 }}}

EnforcedStyleForEmptyBraces: no_space（默认）

# The `no_space` EnforcedStyleForEmptyBraces style enforces that
# empty hash braces do not contain spaces.

# bad
foo = { }
bar = {    }
baz = {
}

# good
foo = {}
bar = {}
baz = {}

EnforcedStyleForEmptyBraces: space

# The `space` EnforcedStyleForEmptyBraces style enforces that
# empty hash braces contain space.

# bad
foo = {}

# good
foo = { }
foo = {    }
foo = {
}

可配置属性

名称 默认值 可配置值

EnforcedStyle

space

space, no_space, compact

EnforcedStyleForEmptyBraces

no_space

space, no_space

参考

Layout/SpaceInsideParens

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.22

检查普通圆括号内的空格。

示例

EnforcedStyle: no_space（默认）

# The `no_space` style enforces that parentheses do not have spaces.

# bad
f( 3)
g = (a + 3 )
f( )

# good
f(3)
g = (a + 3)
f()

EnforcedStyle: space

# The `space` style enforces that parentheses have a space at the
# beginning and end.
# Note: Empty parentheses should not have spaces.

# bad
f(3)
g = (a + 3)
y( )

# good
f( 3 )
g = ( a + 3 )
y()

EnforcedStyle: compact

# The `compact` style enforces that parentheses have a space at the
# beginning with the exception that successive parentheses are allowed.
# Note: Empty parentheses should not have spaces.

# bad
f(3)
g = (a + 3)
y( )
g( f( x ) )
g( f( x( 3 ) ), 5 )
g( ( ( 3 + 5 ) * f) ** x, 5 )

# good
f( 3 )
g = ( a + 3 )
y()
g( f( x ))
g( f( x( 3 )), 5 )
g((( 3 + 5 ) * f ) ** x, 5 )

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_space

space, compact, no_space

参考文献

Layout/SpaceInsidePercentLiteralDelimiters

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查 %i/%w/%x 字面量定界符内不必要的额外空格。

示例

# bad
%i( foo bar baz )

# good
%i(foo bar baz)

# bad
%w( foo bar baz )

# good
%w(foo bar baz)

# bad
%x(  ls -l )

# good
%x(ls -l)

# bad
%w( )
%w(
)

# good
%w()

Layout/SpaceInsideRangeLiteral

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查范围字面量内的空格。

示例

# bad
1 .. 3

# good
1..3

# bad
'a' .. 'z'

# good
'a'..'z'

参考文献

Layout/SpaceInsideReferenceBrackets

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.52

0.53

检查引用括号是否根据配置有或没有周围空格。

示例

EnforcedStyle: no_space（默认）

# The `no_space` style enforces that reference brackets have
# no surrounding space.

# bad
hash[ :key ]
array[ index ]

# good
hash[:key]
array[index]

EnforcedStyle: space

# The `space` style enforces that reference brackets have
# surrounding space.

# bad
hash[:key]
array[index]

# good
hash[ :key ]
array[ index ]

EnforcedStyleForEmptyBrackets: no_space（默认）

# The `no_space` EnforcedStyleForEmptyBrackets style enforces that
# empty reference brackets do not contain spaces.

# bad
foo[ ]
foo[     ]
foo[
]

# good
foo[]

EnforcedStyleForEmptyBrackets: space

# The `space` EnforcedStyleForEmptyBrackets style enforces that
# empty reference brackets contain exactly one space.

# bad
foo[]
foo[    ]
foo[
]

# good
foo[ ]

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_space

space, no_space

EnforcedStyleForEmptyBrackets

no_space

space, no_space

Layout/SpaceInsideStringInterpolation

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

-

检查字符串插值内的空格。

示例

EnforcedStyle: no_space（默认）

# bad
   var = "This is the #{ space } example"

# good
   var = "This is the #{no_space} example"

EnforcedStyle: space

# bad
   var = "This is the #{no_space} example"

# good
   var = "This is the #{ space } example"

可配置属性

名称 默认值 可配置值

EnforcedStyle

no_space

space, no_space

参考文献

Layout/TrailingEmptyLines

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

0.77

查找源代码中的尾随空白行和最终换行符。

示例

EnforcedStyle: final_newline（默认）

# `final_newline` looks for one newline at the end of files.

# bad
class Foo; end

# EOF

# bad
class Foo; end # EOF

# good
class Foo; end
# EOF

EnforcedStyle: final_blank_line

# `final_blank_line` looks for one blank line followed by a new line
# at the end of files.

# bad
class Foo; end
# EOF

# bad
class Foo; end # EOF

# good
class Foo; end

# EOF

可配置属性

名称 默认值 可配置值

EnforcedStyle

final_newline

final_newline, final_blank_line

参考文献

Layout/TrailingWhitespace

默认启用 安全 支持自动更正 添加版本 更改版本

已启用

是

始终

0.49

1.0

查找源代码中的尾随空格。

示例

# The line in this example contains spaces after the 0.
# bad
x = 0

# The line in this example ends directly after the 0.
# good
x = 0

AllowInHeredoc: false（默认）

# The line in this example contains spaces after the 0.
# bad
code = <<~RUBY
  x = 0
RUBY

# ok
code = <<~RUBY
  x = 0 #{}
RUBY

# good
trailing_whitespace = ' '
code = <<~RUBY
  x = 0#{trailing_whitespace}
RUBY

AllowInHeredoc: true

# The line in this example contains spaces after the 0.
# good
code = <<~RUBY
  x = 0
RUBY

可配置属性

名称 默认值 可配置值

AllowInHeredoc

false

布尔值

参考文献

AllowMultilineFinalElement

AllowMultilineFinalElement 是一个布尔选项（默认情况下为 false），它在以下 Layout 规则中可用

  • FirstArrayElementLineBreak

  • FirstHashElementLineBreak

  • FirstMethodArgumentLineBreak

  • FirstMethodParameterLineBreak

  • MultilineArrayLineBreaks

  • MultilineHashKeyLineBreaks

  • MultilineMethodArgumentLineBreaks

  • MultilineMethodParameterLineBreaks

这些警察会忽略它们各自的表达式，如果所有或表达式的元素都在同一行。如果将 AllowMultilineFinalElement 设置为 true，警察也会忽略多行表达式，如果最后一个元素从同一行开始，但在不同的行结束。

这与 Layout/LineLength 很好地配合使用，以便在换行时将元素显示在单独的行上，同时不会影响已经足够短的表达式，并且仅因其最后一个元素而被认为是多行。

每个警察都可以独立配置，允许对代码库中被认为是好的 ok 的内容进行更细粒度的控制。

示例

以下是一些现实世界中表达式的示例，这些表达式被它们各自的警察包装，但在将 AllowMultilineFinalElement 设置为 true 时被认为是 ok 的。

# 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