Sign upLogin

BLSQ/orbf2

View on GitHub
Star
app/services/groups/list_history.rb

Summary

Maintainability
A
2 hrs
Test Coverage
C
76%

Method has too many lines. [35/10]
Open

  def map_to_history(selected_orgunit, period, subcontract_groupset_id, pyramid)
    orgunit = pyramid.org_unit(selected_orgunit.id)
    unless orgunit
      return {
        id:     selected_orgunit.id,
Severity: Minor
Found in app/services/groups/list_history.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method has too many lines. [19/10]
Open

  def to_group(g, pyramid)
    result = { id: g.id, name: g.name }
    if g.organisation_unit_group_set
      group_set = pyramid.org_unit_group_set(g.organisation_unit_group_set["id"])
      if group_set
Severity: Minor
Found in app/services/groups/list_history.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method has too many lines. [11/10]
Open

  def fetch_selected_orgunits(project, pyramids, selected_regions, rejected_districts = [])
    orgunits = Set.new
    pyramids.each_value do |pyramid|
      contracted = pyramid.org_units_in_group(project.entity_group.external_reference)
      orgunits.merge(contracted)
Severity: Minor
Found in app/services/groups/list_history.rb by rubocop

This cop checks if the length of a method exceeds some maximum value. Comment lines can optionally be ignored. The maximum allowed length is configurable.

Method map_to_history has 35 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  def map_to_history(selected_orgunit, period, subcontract_groupset_id, pyramid)
    orgunit = pyramid.org_unit(selected_orgunit.id)
    unless orgunit
      return {
        id:     selected_orgunit.id,
Severity: Minor
Found in app/services/groups/list_history.rb - About 1 hr to fix

    Method to_group has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
    Open

      def to_group(g, pyramid)
    result = { id: g.id, name: g.name }
    if g.organisation_unit_group_set
      group_set = pyramid.org_unit_group_set(g.organisation_unit_group_set["id"])
      if group_set
    Severity: Minor
    Found in app/services/groups/list_history.rb - About 45 mins to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Do not write to stdout. Use Rails's logger if you want to log.
    Open

              puts "#{group_params.project.name} : buggy groupset : #{groupset_ref}"
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    This cop checks for the use of output calls like puts and print

    Example:

    # bad
puts 'A debug message'
pp 'A debug message'
print 'A debug message'

# good
Rails.logger.debug 'A debug message'

    Align the elements of a hash literal if they span more than one line.
    Open

          id:                       orgunit.id,
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Method parameter must be at least 3 characters long.
    Open

      def to_orgunit(o)
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    This cop checks method parameter names for how descriptive they are. It is highly configurable.

    The MinNameLength config option takes an integer. It represents the minimum amount of characters the name must be. Its default is 3. The AllowNamesEndingInNumbers config option takes a boolean. When set to false, this cop will register offenses for names ending with numbers. Its default is false. The AllowedNames config option takes an array of whitelisted names that will never register an offense. The ForbiddenNames config option takes an array of blacklisted names that will always register an offense.

    Example:

    # bad
def bar(varOne, varTwo)
  varOne + varTwo
end

# With `AllowNamesEndingInNumbers` set to false
def foo(num1, num2)
  num1 * num2
end

# With `MinArgNameLength` set to number greater than 1
def baz(a, b, c)
  do_stuff(a, b, c)
end

# good
def bar(thud, fred)
  thud + fred
end

def foo(speed, distance)
  speed * distance
end

def baz(age_a, height_b, gender_c)
  do_stuff(age_a, height_b, gender_c)
end

    Avoid chaining a method call on a do...end block.
    Open

          end.compact
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    This cop checks for methods called on a do...end block. The point of this check is that it's easy to miss the call tacked on to the block when reading code.

    Example:

    a do
  b
end.c

    Align the elements of a hash literal if they span more than one line.
    Open

            name:   name(selected_orgunit),
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Method parameter must be at least 3 characters long.
    Open

      def to_group(g, pyramid)
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    This cop checks method parameter names for how descriptive they are. It is highly configurable.

    The MinNameLength config option takes an integer. It represents the minimum amount of characters the name must be. Its default is 3. The AllowNamesEndingInNumbers config option takes a boolean. When set to false, this cop will register offenses for names ending with numbers. Its default is false. The AllowedNames config option takes an array of whitelisted names that will never register an offense. The ForbiddenNames config option takes an array of blacklisted names that will always register an offense.

    Example:

    # bad
def bar(varOne, varTwo)
  varOne + varTwo
end

# With `AllowNamesEndingInNumbers` set to false
def foo(num1, num2)
  num1 * num2
end

# With `MinArgNameLength` set to number greater than 1
def baz(a, b, c)
  do_stuff(a, b, c)
end

# good
def bar(thud, fred)
  thud + fred
end

def foo(speed, distance)
  speed * distance
end

def baz(age_a, height_b, gender_c)
  do_stuff(age_a, height_b, gender_c)
end

    Use nested module/class definitions instead of compact style.
    Open

    class Groups::ListHistory
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    This cop checks the style of children definitions at classes and modules. Basically there are two different styles:

    Example: EnforcedStyle: nested (default)

    # good
# have each child on its own line
class Foo
  class Bar
  end
end

    Example: EnforcedStyle: compact

    # good
# combine definitions as much as possible
class Foo::Bar
end

    The compact style is only forced for classes/modules with one child.

    Align the elements of a hash literal if they span more than one line.
    Open

          contract_group:           contract_groups.map { |g| to_group(g, pyramid) },
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Align the elements of a hash literal if they span more than one line.
    Open

          name:                     name(orgunit),
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Align the elements of a hash literal if they span more than one line.
    Open

          contract_members:         subcontracted_ous.map { |ou| to_orgunit(ou) }
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Align the elements of a hash literal if they span more than one line.
    Open

            id:     selected_orgunit.id,
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Align the elements of a hash literal if they span more than one line.
    Open

          period:                   period,
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    Align the elements of a hash literal if they span more than one line.
    Open

          ancestors:                parents.map { |parent| to_orgunit(parent) },
    Severity: Minor
    Found in app/services/groups/list_history.rb by rubocop

    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)

    Alternatively you can specify multiple allowed styles. That's done by passing a list of styles to EnforcedStyles.

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

    There are no issues that match your filters.

    Category
    Status