hackedteam/core-linux

View on GitHub

Showing 117 of 141 total issues

Function next has a Cognitive Complexity of 19 (exceeds 5 allowed). Consider refactoring.
Open

    def next (self):
        # Ensure we have enough frames for a full signal emission
        self.fill()

        # Are we at the end?
Severity: Minor
Found in core/multilib/x86_64/usr/share/glib-2.0/gdb/gobject.py - About 2 hrs 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

Function print_signal_prototype has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def print_signal_prototype(self, i, s, in_synopsis):
        max_signal_len = 0
        if in_synopsis:
            for _s in i.signals:
                max_signal_len = max(len(_s.name), max_signal_len)

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

Function generate_skeleton has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def generate_skeleton(self, i):
        # class boilerplate
        self.c.write('/* ------------------------------------------------------------------------ */\n'
                     '\n')

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

Function generate_skeleton has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def generate_skeleton(self, i):
        # class boilerplate
        self.c.write('/* ------------------------------------------------------------------------ */\n'
                     '\n')

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

Function generate_property_accessors has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def generate_property_accessors(self, i):
        for p in i.properties:
            # getter
            if p.readable and p.writable:
                hint = 'Since this D-Bus property is both readable and writable, it is meaningful to use this function on both the client- and service-side.'

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

Function generate_property_accessors has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def generate_property_accessors(self, i):
        for p in i.properties:
            # getter
            if p.readable and p.writable:
                hint = 'Since this D-Bus property is both readable and writable, it is meaningful to use this function on both the client- and service-side.'

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

Function print_signal_prototype has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
Open

    def print_signal_prototype(self, i, s, in_synopsis):
        max_signal_len = 0
        if in_synopsis:
            for _s in i.signals:
                max_signal_len = max(len(_s.name), max_signal_len)

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

File codegen_docbook.py has 267 lines of code (exceeds 250 allowed). Consider refactoring.
Open

# -*- Mode: Python -*-

# GDBus - GLib D-Bus Library
#
# Copyright (C) 2008-2011 Red Hat, Inc.

    File codegen_docbook.py has 267 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    # -*- Mode: Python -*-
    
    # GDBus - GLib D-Bus Library
    #
    # Copyright (C) 2008-2011 Red Hat, Inc.

      Function generate_proxy has 59 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          def generate_proxy(self, i):
              # class boilerplate
              self.c.write('/* ------------------------------------------------------------------------ */\n'
                           '\n')
      
      

        Function generate_proxy has 59 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            def generate_proxy(self, i):
                # class boilerplate
                self.c.write('/* ------------------------------------------------------------------------ */\n'
                             '\n')
        
        

          Function print_property_prototype has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

              def print_property_prototype(self, i, p, in_synopsis):
                  max_property_len = 0
                  if in_synopsis:
                      for _p in i.properties:
                          max_property_len = max(len(_p.name), max_property_len)

          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

          Function print_property_prototype has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
          Open

              def print_property_prototype(self, i, p, in_synopsis):
                  max_property_len = 0
                  if in_synopsis:
                      for _p in i.properties:
                          max_property_len = max(len(_p.name), max_property_len)

          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

          Function generate_object_manager_client has 40 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              def generate_object_manager_client(self):
                  self.c.write('/* ------------------------------------------------------------------------\n'
                               ' * Code for ObjectManager client\n'
                               ' * ------------------------------------------------------------------------\n'
                               ' */\n'

            Function generate_object_manager_client has 40 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

                def generate_object_manager_client(self):
                    self.c.write('/* ------------------------------------------------------------------------\n'
                                 ' * Code for ObjectManager client\n'
                                 ' * ------------------------------------------------------------------------\n'
                                 ' */\n'

              Function pretty_printer_lookup has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

              def pretty_printer_lookup (val):
                  # None yet, want things like hash table and list
              
                  type = val.type.unqualified()
              
              
              Severity: Minor
              Found in core/multilib/i386/usr/share/glib-2.0/gdb/glib.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

              Function generate_annotations has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

                  def generate_annotations(self, prefix, annotations):
                      if annotations == None:
                          return
              
                      n = 0

              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 13 (exceeds 5 allowed). Consider refactoring.
              Open

                def self.run(options)
              
                  begin
                    c = CoreDeveloper.new
                    c.name = options[:name]
              Severity: Minor
              Found in build/script/rcs-core.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

              Function generate_annotations has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

                  def generate_annotations(self, prefix, annotations):
                      if annotations == None:
                          return
              
                      n = 0

              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

              Function pretty_printer_lookup has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
              Open

              def pretty_printer_lookup (val):
                  # None yet, want things like hash table and list
              
                  type = val.type.unqualified()
              
              
              Severity: Minor
              Found in core/multilib/x86_64/usr/share/glib-2.0/gdb/glib.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

              Severity
              Category
              Status
              Source
              Language