codeclimate/codeclimate-duplication

View on GitHub

Showing 107 of 107 total issues

Class Base has 23 methods (exceeds 20 allowed). Consider refactoring.
Open

      class Base
        RESCUABLE_ERRORS = [
          ::CC::Engine::Analyzers::ParserError,
          ::Errno::ENOENT,
          ::Racc::ParseError,
Severity: Minor
Found in lib/cc/engine/analyzers/analyzer_base.rb - About 2 hrs to fix

    Method parse_sexp has 32 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

          def parse_sexp
            token = next_token
    
            case token
            when "(" then
    Severity: Minor
    Found in lib/cc/engine/analyzers/analyzer_base.rb - About 1 hr to fix

      Function cast_value has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
      Open

      def cast_value(value):
          if value is None or isinstance(value, (bool, string_type())):
              return value
          elif PY3 and isinstance(value, bytes):
              return value.decode()
      Severity: Minor
      Found in lib/cc/engine/analyzers/python/parser.py - 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 flatter has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
      Open

        def flatter
          result = dup.clear
          result.mass = mass
      
          each_with_object(result) do |s, r|
      Severity: Minor
      Found in lib/ccflay.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

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

              def report
                flay.analyze.each do |issue|
                  violations = new_violations(issue)
      
                  violations.each do |violation|
      Severity: Minor
      Found in lib/cc/engine/analyzers/reporter.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

      Method run has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
      Open

              def run(file)
                if (skip_reason = skip?(file))
                  CC.logger.info("Skipping file #{file} because #{skip_reason}")
                  nil
                else
      Severity: Minor
      Found in lib/cc/engine/analyzers/analyzer_base.rb - About 35 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

      Method parse_sexp has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
      Open

            def parse_sexp
              token = next_token
      
              case token
              when "(" then
      Severity: Minor
      Found in lib/cc/engine/analyzers/analyzer_base.rb - About 35 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

      Avoid too many return statements within this function.
      Open

              return value
      Severity: Major
      Found in lib/cc/engine/analyzers/python/parser.py - About 30 mins to fix

        Avoid too many return statements within this function.
        Open

                return [cast_value(v) for v in value]
        Severity: Major
        Found in lib/cc/engine/analyzers/python/parser.py - About 30 mins to fix

          Avoid too many return statements within this function.
          Open

                  return to_json(value)
          Severity: Major
          Found in lib/cc/engine/analyzers/python/parser.py - About 30 mins to fix

            Method files has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
            Open

                    def files
                      engine_config.include_paths.flat_map do |path|
                        pathname = Pathname.new(path)
                        if pathname.directory? && !pathname.cleanpath.symlink?
                          expand(path)
            Severity: Minor
            Found in lib/cc/engine/analyzers/file_list.rb - About 25 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

            Use def with parentheses when there are parameters.
            Open

              def post_filter *patterns
            Severity: Minor
            Found in lib/ccflay.rb by rubocop

            This cops checks for parentheses around the arguments in method definitions. Both instance and class/singleton methods are checked.

            Example: EnforcedStyle: require_parentheses (default)

            # The `require_parentheses` style requires method definitions
            # to always use parentheses
            
            # bad
            def bar num1, num2
              num1 + num2
            end
            
            def foo descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name
              do_something
            end
            
            # good
            def bar(num1, num2)
              num1 + num2
            end
            
            def foo(descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name)
              do_something
            end

            Example: EnforcedStyle: requirenoparentheses

            # The `require_no_parentheses` style requires method definitions
            # to never use parentheses
            
            # bad
            def bar(num1, num2)
              num1 + num2
            end
            
            def foo(descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name)
              do_something
            end
            
            # good
            def bar num1, num2
              num1 + num2
            end
            
            def foo descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name
              do_something
            end

            Example: EnforcedStyle: requirenoparenthesesexceptmultiline

            # The `require_no_parentheses_except_multiline` style prefers no
            # parantheses when method definition arguments fit on single line,
            # but prefers parantheses when arguments span multiple lines.
            
            # bad
            def bar(num1, num2)
              num1 + num2
            end
            
            def foo descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name
              do_something
            end
            
            # good
            def bar num1, num2
              num1 + num2
            end
            
            def foo(descriptive_var_name,
                    another_descriptive_var_name,
                    last_descriptive_var_name)
              do_something
            end

            Missing magic comment # frozen_string_literal: true.
            Open

            require "cc/parser"
            Severity: Minor
            Found in lib/cc/engine/processed_source.rb by rubocop

            This cop is designed to help upgrade to Ruby 3.0. It will add the comment # frozen_string_literal: true to the top of files to enable frozen string literals. Frozen string literals may be default in Ruby 3.0. The comment will be added below a shebang and encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.

            Example: EnforcedStyle: when_needed (default)

            # The `when_needed` style will add the frozen string literal comment
            # to files only when the `TargetRubyVersion` is set to 2.3+.
            # bad
            module Foo
              # ...
            end
            
            # good
            # frozen_string_literal: true
            
            module Foo
              # ...
            end

            Example: EnforcedStyle: always

            # The `always` style will always add the frozen string literal comment
            # to a file, regardless of the Ruby version or if `freeze` or `<<` are
            # called on a string literal.
            # bad
            module Bar
              # ...
            end
            
            # good
            # frozen_string_literal: true
            
            module Bar
              # ...
            end

            Example: EnforcedStyle: never

            # The `never` will enforce that the frozen string literal comment does
            # not exist in a file.
            # bad
            # frozen_string_literal: true
            
            module Baz
              # ...
            end
            
            # good
            module Baz
              # ...
            end

            Do not freeze immutable objects, as freezing them has no effect.
            Open

                    IDENTICAL_CODE_CHECK_LEGACY_NAME = "Identical code".freeze

            This cop check for uses of Object#freeze on immutable objects.

            Example:

            # bad
            CONST = 1.freeze
            
            # good
            CONST = 1

            Redundant self detected.
            Open

                self.hashes.delete_if { |_, sexps|
            Severity: Minor
            Found in lib/ccflay.rb by rubocop

            This cop checks for redundant uses of self.

            The usage of self is only needed when:

            • Sending a message to same object with zero arguments in presence of a method name clash with an argument or a local variable.

            • Calling an attribute writer to prevent an local variable assignment.

            Note, with using explicit self you can only send messages with public or protected scope, you cannot send private messages this way.

            Note we allow uses of self with operators because it would be awkward otherwise.

            Example:

            # bad
            def foo(bar)
              self.baz
            end
            
            # good
            def foo(bar)
              self.bar  # Resolves name clash with the argument.
            end
            
            def foo
              bar = 1
              self.bar  # Resolves name clash with the local variable.
            end
            
            def foo
              %w[x y z].select do |bar|
                self.bar == bar  # Resolves name clash with argument of the block.
              end
            end

            Missing magic comment # frozen_string_literal: true.
            Open

            module CC
            Severity: Minor
            Found in lib/cc/engine/sexp_builder.rb by rubocop

            This cop is designed to help upgrade to Ruby 3.0. It will add the comment # frozen_string_literal: true to the top of files to enable frozen string literals. Frozen string literals may be default in Ruby 3.0. The comment will be added below a shebang and encoding comment. The frozen string literal comment is only valid in Ruby 2.3+.

            Example: EnforcedStyle: when_needed (default)

            # The `when_needed` style will add the frozen string literal comment
            # to files only when the `TargetRubyVersion` is set to 2.3+.
            # bad
            module Foo
              # ...
            end
            
            # good
            # frozen_string_literal: true
            
            module Foo
              # ...
            end

            Example: EnforcedStyle: always

            # The `always` style will always add the frozen string literal comment
            # to a file, regardless of the Ruby version or if `freeze` or `<<` are
            # called on a string literal.
            # bad
            module Bar
              # ...
            end
            
            # good
            # frozen_string_literal: true
            
            module Bar
              # ...
            end

            Example: EnforcedStyle: never

            # The `never` will enforce that the frozen string literal comment does
            # not exist in a file.
            # bad
            # frozen_string_literal: true
            
            module Baz
              # ...
            end
            
            # good
            module Baz
              # ...
            end

            Avoid comma after the last item of an array.
            Open

                        "(comments ___)",
            Severity: Minor
            Found in lib/cc/engine/analyzers/go/main.rb by rubocop

            This cop checks for trailing comma in array and hash 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
            ]

            Avoid comma after the last item of a hash.
            Open

                          },

            This cop checks for trailing comma in array and hash 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
            ]

            Do not freeze immutable objects, as freezing them has no effect.
            Open

                      LANGUAGE = "kotlin".freeze

            This cop check for uses of Object#freeze on immutable objects.

            Example:

            # bad
            CONST = 1.freeze
            
            # good
            CONST = 1

            Align else with if.
            Open

                        else

            This cops checks the alignment of else keywords. Normally they should be aligned with an if/unless/while/until/begin/def keyword, but there are special cases when they should follow the same rules as the alignment of end.

            Example:

            # bad
            if something
              code
             else
              code
            end
            
            # bad
            if something
              code
             elsif something
              code
            end
            
            # good
            if something
              code
            else
              code
            end
            Severity
            Category
            Status
            Source
            Language