Sign upLogin

autotelik/datashift_journey

View on GitHub
Star
app/controllers/datashift_journey/api/v1/states_controller.rb

Summary

Maintainability
A
1 hr
Test Coverage

Method index has 30 lines of code (exceeds 25 allowed). Consider refactoring.
Open

        def index

          state_paths = []

          DatashiftJourney.journey_plan_class.new.state_paths.each_with_index do |s, i|
Severity: Minor
Found in app/controllers/datashift_journey/api/v1/states_controller.rb - About 1 hr to fix

    Use 2 spaces for indentation in a hash, relative to the start of the line where the left curly brace is.
    Open

                    name: e.name,
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cops checks the indentation of the first key in a hash literal where the opening brace and the first key are on separate lines. The other keys' indentations are handled by the AlignHash cop.

    By default, Hash literals that are arguments in a method call with parentheses, and where the opening curly brace of the hash is on the same line as the opening parenthesis of the method call, shall have their first key indented one step (two spaces) more than the position inside the opening parenthesis.

    Other hash literals shall have their first key indented one step more than the start of the line where the opening curly brace is.

    This default style is called 'specialinsideparentheses'. Alternative styles are 'consistent' and 'align_braces'. Here are examples:

    Example: EnforcedStyle: specialinsideparentheses (default)

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

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

    Example: EnforcedStyle: consistent

    # The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# seprate 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
})

    Example: 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
}

# good
and_now_for_something = {
                          completely: :different
                        }

    Use 2 spaces for indentation in a hash, relative to the start of the line where the left curly brace is.
    Open

                    index: i, events: s.events, from_name: s.from_name, to_name: s.to_name
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cops checks the indentation of the first key in a hash literal where the opening brace and the first key are on separate lines. The other keys' indentations are handled by the AlignHash cop.

    By default, Hash literals that are arguments in a method call with parentheses, and where the opening curly brace of the hash is on the same line as the opening parenthesis of the method call, shall have their first key indented one step (two spaces) more than the position inside the opening parenthesis.

    Other hash literals shall have their first key indented one step more than the start of the line where the opening curly brace is.

    This default style is called 'specialinsideparentheses'. Alternative styles are 'consistent' and 'align_braces'. Here are examples:

    Example: EnforcedStyle: specialinsideparentheses (default)

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

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

    Example: EnforcedStyle: consistent

    # The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# seprate 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
})

    Example: 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
}

# good
and_now_for_something = {
                          completely: :different
                        }

    Use 2 spaces for indentation in a hash, relative to the start of the line where the left curly brace is.
    Open

                    name: s.name, value: s.value, initial: s.initial, final: s.final?
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cops checks the indentation of the first key in a hash literal where the opening brace and the first key are on separate lines. The other keys' indentations are handled by the AlignHash cop.

    By default, Hash literals that are arguments in a method call with parentheses, and where the opening curly brace of the hash is on the same line as the opening parenthesis of the method call, shall have their first key indented one step (two spaces) more than the position inside the opening parenthesis.

    Other hash literals shall have their first key indented one step more than the start of the line where the opening curly brace is.

    This default style is called 'specialinsideparentheses'. Alternative styles are 'consistent' and 'align_braces'. Here are examples:

    Example: EnforcedStyle: specialinsideparentheses (default)

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

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

    Example: EnforcedStyle: consistent

    # The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# seprate 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
})

    Example: 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
}

# good
and_now_for_something = {
                          completely: :different
                        }

    Final newline missing.
    Open

    end
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    Space inside { missing.
    Open

                        {state_requirement: state_requirement, from: state_requirement[:from].class, to: state_requirement[:to]}
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    Checks that braces used for hash literals have or don't have surrounding space depending on configuration.

    Example: EnforcedStyle: space

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

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

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

    Example: 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}

    Example: 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 } }

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

    Extra empty line detected at method body beginning.
    Open

    
          state_paths = []
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cops checks if empty lines exist around the bodies of methods.

    Example:

    # good

def foo
  # ...
end

# bad

def bar

  # ...

end

    Use 2 spaces for indentation in a hash, relative to the start of the line where the left curly brace is.
    Open

                                     states: states, state_paths: state_paths, events: events
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cops checks the indentation of the first key in a hash literal where the opening brace and the first key are on separate lines. The other keys' indentations are handled by the AlignHash cop.

    By default, Hash literals that are arguments in a method call with parentheses, and where the opening curly brace of the hash is on the same line as the opening parenthesis of the method call, shall have their first key indented one step (two spaces) more than the position inside the opening parenthesis.

    Other hash literals shall have their first key indented one step more than the start of the line where the opening curly brace is.

    This default style is called 'specialinsideparentheses'. Alternative styles are 'consistent' and 'align_braces'. Here are examples:

    Example: EnforcedStyle: specialinsideparentheses (default)

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

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

    Example: EnforcedStyle: consistent

    # The `consistent` style enforces that the first key in a hash
# literal where the opening brace and the first key are on
# seprate 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
})

    Example: 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
}

# good
and_now_for_something = {
                          completely: :different
                        }

    Closing hash brace must be on the same line as the last hash element when opening brace is on the same line as the first hash element.
    Open

              }
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cop checks that the closing brace in a hash literal is either on the same line as the last hash element, or a new line.

    When using the symmetrical (default) style:

    If a hash's opening brace is on the same line as the first element of the hash, then the closing brace should be on the same line as the last element of the hash.

    If a hash's opening brace is on the line above the first element of the hash, then the closing brace should be on the line below the last element of the hash.

    When using the new_line style:

    The closing brace of a multi-line hash literal must be on the line after the last element of the hash.

    When using the same_line style:

    The closing brace of a multi-line hash literal must be on the same line as the last element of the hash.

    Example: EnforcedStyle: symmetrical (default)

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

  # good
  { a: 1,
    b: 2 }

  # good
  {
    a: 1,
    b: 2
  }

    Example: EnforcedStyle: new_line

    # bad
  {
    a: 1,
    b: 2 }

  # bad
  { a: 1,
    b: 2 }

  # good
  { a: 1,
    b: 2
  }

  # good
  {
    a: 1,
    b: 2
  }

    Example: EnforcedStyle: same_line

    # bad
  { a: 1,
    b: 2
  }

  # bad
  {
    a: 1,
    b: 2
  }

  # good
  {
    a: 1,
    b: 2 }

  # good
  { a: 1,
    b: 2 }

    Missing space after #.
    Open

                    #machine: s.machine,
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    This cop checks whether comments have a leading space after the # denoting the start of the comment. The leading space is not required for some RDoc special syntax, like #++, #--, #:nodoc, =begin- and =end comments, "shebang" directives, or rackup options.

    Example:

    # bad
#Some comment

# good
# Some comment

    Space inside } missing.
    Open

                        {state_requirement: state_requirement, from: state_requirement[:from].class, to: state_requirement[:to]}
    Severity: Minor
    Found in app/controllers/datashift_journey/api/v1/states_controller.rb by rubocop

    Checks that braces used for hash literals have or don't have surrounding space depending on configuration.

    Example: EnforcedStyle: space

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

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

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

    Example: 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}

    Example: 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 } }

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

    There are no issues that match your filters.

    Category
    Status