codeRIT/hackathon_manager

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

This cop enforces empty line after guard clause

Example:

# 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

This cop enforces empty line after guard clause

Example:

# 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

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

This cop checks for trailing comma in array literals.

Example: EnforcedStyleForMultiline: consistent_comma

# bad
a = [1, 2,]
 
# good
a = [
  1, 2,
  3,
]
 
# good
a = [
  1,
  2,
]

Example: EnforcedStyleForMultiline: comma

# bad
a = [1, 2,]
 
# good
a = [
  1,
  2,
]

Example: EnforcedStyleForMultiline: no_comma (default)

# bad
a = [1, 2,]
 
# good
a = [
  1,
  2
]

This cop makes sure that rescued exceptions variables are named as expected.

The PreferredName config option takes a String. It represents the required name of the variable. Its default is e.

Example: PreferredName: e (default)

# bad
begin
  # do something
rescue MyException => exception
  # do something
end
 
# good
begin
  # do something
rescue MyException => e
  # do something
end

Example: PreferredName: exception

# bad
begin
  # do something
rescue MyException => e
  # do something
end
 
# good
begin
  # do something
rescue MyException => exception
  # do something
end

This cop checks for rescuing StandardError. There are two supported styles implicit and explicit. This cop will not register an offense if any error other than StandardError is specified.

Example: EnforcedStyle: implicit

# `implicit` will enforce using `rescue` instead of
# `rescue StandardError`.
 
# bad
begin
  foo
rescue StandardError
  bar
end
 
# good
begin
  foo
rescue
  bar
end
 
# good
begin
  foo
rescue OtherError
  bar
end
 
# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

Example: EnforcedStyle: explicit (default)

# `explicit` will enforce using `rescue StandardError`
# instead of `rescue`.
 
# bad
begin
  foo
rescue
  bar
end
 
# good
begin
  foo
rescue StandardError
  bar
end
 
# good
begin
  foo
rescue OtherError
  bar
end
 
# good
begin
  foo
rescue StandardError, SecurityError
  bar
end

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

This cop checks if empty lines around the bodies of classes match the configuration.

Example: EnforcedStyle: empty_lines

# good
 
class Foo
 
  def bar
    # ...
  end
 
end

Example: EnforcedStyle: emptylinesexcept_namespace

# good
 
class Foo
  class Bar
 
    # ...
 
  end
end

Example: EnforcedStyle: emptylinesspecial

# good
class Foo
 
  def bar; end
 
end

Example: Enforcedstyle: beginning_only

# good
 
class Foo
 
  def bar
    # ...
  end
end

Example: Enforcedstyle: ending_only

# good
 
class Foo
  def bar
    # ...
  end
 
end

Example: EnforcedStyle: noemptylines (default)

# good
 
class Foo
  def bar
    # ...
  end
end

Check that the keys, separators, and values of a multi-line hash literal are aligned according to configuration. The configuration options are:

- key (left align keys, one space before hash rockets and values)
- separator (align hash rockets and colons, right align keys)
- table (left align keys, hash rockets, and values)

The treatment of hashes passed as the last argument to a method call can also be configured. The options are:

- always_inspect
- always_ignore
- ignore_implicit (without curly braces)
- ignore_explicit (with curly braces)

Example: EnforcedHashRocketStyle: key (default)

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

Example: EnforcedHashRocketStyle: separator

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

Example: EnforcedHashRocketStyle: table

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

Example: EnforcedColonStyle: key (default)

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

Example: EnforcedColonStyle: separator

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

Example: EnforcedColonStyle: table

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

Example: EnforcedLastArgumentHashStyle: always_inspect (default)

# 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
})

Example: EnforcedLastArgumentHashStyle: always_ignore

# Ignore both implicit and explicit hashes.
 
# good
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})

Example: EnforcedLastArgumentHashStyle: ignore_implicit

# Ignore only implicit hashes.
 
# bad
do_something({foo: 1,
  bar: 2})
 
# good
do_something(foo: 1,
  bar: 2)

Example: EnforcedLastArgumentHashStyle: ignore_explicit

# Ignore only explicit hashes.
 
# bad
do_something(foo: 1,
  bar: 2)
 
# good
do_something({foo: 1,
  bar: 2})