bbatsov/rubocop

View on GitHub

Showing 665 of 665 total issues

Method offense_range has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

        def offense_range(node)
          if reject_method_with_block_pass?(node) || grep_v_with_nil?(node)
            range(node, node)
          else
            block_node = node.parent
Severity: Minor
Found in lib/rubocop/cop/style/collection_compact.rb - About 1 hr 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

Method run has 33 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    def run(args = ARGV)
      @options, paths = Options.new.parse(args)
      @env = Environment.new(@options, @config_store, paths)

      profile_if_needed do
Severity: Minor
Found in lib/rubocop/cli.rb - About 1 hr to fix

    Method override_department_setting_for_cops has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

        def override_department_setting_for_cops(base_hash, derived_hash)
          derived_hash.each_key do |key|
            next unless key =~ %r{(.*)/.*}
    
            department = Regexp.last_match(1)
    Severity: Minor
    Found in lib/rubocop/config_loader_resolver.rb - About 1 hr 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

    Method each_missing_space has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

          def each_missing_space(tokens)
            tokens.each_cons(2) do |token1, token2|
              next unless kind(token2)
              next unless space_missing?(token1, token2)
              next if space_required_after?(token1)
    Severity: Minor
    Found in lib/rubocop/cop/mixin/space_before_punctuation.rb - About 1 hr 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

    Method relevant_assignment_lines has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

          def relevant_assignment_lines(line_range)
            result                        = []
            original_line_indent          = processed_source.line_indentation(line_range.first)
            relevant_line_indent_at_level = true
    
    
    Severity: Minor
    Found in lib/rubocop/cop/mixin/preceding_following_alignment.rb - About 1 hr 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

    Method def_node_that_require_parentheses has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

          def def_node_that_require_parentheses(node)
            last_pair = node.parent.pairs.last
            return unless last_pair.key.source == last_pair.value.source
            return unless (dispatch_node = find_ancestor_method_dispatch_node(node))
            return if dispatch_node.assignment_method?
    Severity: Minor
    Found in lib/rubocop/cop/mixin/hash_shorthand_syntax.rb - About 1 hr 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

    Method aligned_with_line? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

          def aligned_with_line?(line_nos, range, indent = nil)
            line_nos.each do |lineno|
              next if aligned_comment_lines.include?(lineno + 1)
    
              line = processed_source.lines[lineno]
    Severity: Minor
    Found in lib/rubocop/cop/mixin/preceding_following_alignment.rb - About 1 hr 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

    Method on_new_investigation has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_new_investigation
              processed_source.comments.each do |comment|
                next if comment.text !~ DISABLE_COMMENT_FORMAT
    
                offset = Regexp.last_match(1).length
    Severity: Minor
    Found in lib/rubocop/cop/migration/department_name.rb - About 1 hr 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

    Method contained_by_breakable_collection_on_same_line? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

          def contained_by_breakable_collection_on_same_line?(node)
            node.each_ancestor.find do |ancestor|
              # Ignore ancestors on different lines.
              break if ancestor.first_line != node.first_line
    
    
    Severity: Minor
    Found in lib/rubocop/cop/mixin/check_line_breakable.rb - About 1 hr 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

    Method resolve_inheritance has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

        def resolve_inheritance(path, hash, file, debug) # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
          inherited_files = Array(hash['inherit_from'])
          base_configs(path, inherited_files, file)
            .each_with_index.reverse_each do |base_config, index|
            override_department_setting_for_cops(base_config, hash)
    Severity: Minor
    Found in lib/rubocop/config_loader_resolver.rb - About 1 hr 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

    Method check_for_unused_assignments has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def check_for_unused_assignments(variable)
              return if variable.should_be_unused?
    
              variable.assignments.each do |assignment|
                next if assignment.used? || part_of_ignored_node?(assignment.node)
    Severity: Minor
    Found in lib/rubocop/cop/lint/useless_assignment.rb - About 1 hr 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

    Method on_send has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_send(node)
              def_node = node.each_ancestor(:def, :defs).first
              return unless def_node
    
              enum_conversion_call?(node) do |method_node, arguments|
    Severity: Minor
    Found in lib/rubocop/cop/lint/to_enum_arguments.rb - About 1 hr 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

    Method on_send has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_send(node)
              return if allow_send? && !node.method?(:public_send)
              return unless (first_argument = node.first_argument)
              return unless STATIC_METHOD_NAME_NODE_TYPES.include?(first_argument.type)
    
    
    Severity: Minor
    Found in lib/rubocop/cop/style/send_with_literal_method_name.rb - About 1 hr 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

    Method add_safe_nav_to_all_methods_in_chain has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def add_safe_nav_to_all_methods_in_chain(corrector,
                                                     start_method,
                                                     method_chain)
              start_method.each_ancestor do |ancestor|
                break unless %i[send block].include?(ancestor.type)
    Severity: Minor
    Found in lib/rubocop/cop/style/safe_navigation.rb - About 1 hr 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

    Method on_send has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_send(node)
              return if node.arguments.empty?
              return unless node.arguments.all?(&:array_type?)
    
              offense = offense_range(node)
    Severity: Minor
    Found in lib/rubocop/cop/style/concat_array_literals.rb - About 1 hr 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

    Method keyword_arg_same? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def keyword_arg_same?(def_arg, super_arg)
              return false unless def_arg.kwarg_type? || def_arg.kwoptarg_type?
              return false unless (pair_node = super_arg).pair_type?
              return false unless (sym_node = pair_node.key).sym_type?
              return false unless (lvar_node = pair_node.value).lvar_type?
    Severity: Minor
    Found in lib/rubocop/cop/style/super_arguments.rb - About 1 hr 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

    Method on_def has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_def(node)
              return if acceptable?(node)
    
              if node.body.nil?
                register_offense(node, MSG_EMPTY)
    Severity: Minor
    Found in lib/rubocop/cop/style/redundant_initialize.rb - About 1 hr 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

    Method complexity_score_for has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def complexity_score_for(node)
              case node.type
              when :case
                # If cond is nil, that means each when has an expression that
                # evaluates to true or false. It's just an alternative to
    Severity: Minor
    Found in lib/rubocop/cop/metrics/perceived_complexity.rb - About 1 hr 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

    Method exclusive_with? has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

              def exclusive_with?(other)
                return false unless other
                return false if may_jump_to_other_branch?
    
                other.each_ancestor(include_self: true) do |other_ancestor|
    Severity: Minor
    Found in lib/rubocop/cop/variable_force/branch.rb - About 1 hr 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

    Method on_new_investigation has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

            def on_new_investigation
              last_line = last_line(processed_source)
    
              processed_source.raw_source.each_line.with_index do |line, index|
                break if index >= last_line
    Severity: Minor
    Found in lib/rubocop/cop/layout/end_of_line.rb - About 1 hr 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

    Severity
    Category
    Status
    Source
    Language