edgewall/trac

View on GitHub

Showing 1,372 of 1,372 total issues

Avoid deeply nested control flow statements.
Open

                        if kwarg_name in func_kwargs_map:
                            messages_kwargs[kwarg_name] = message
                        else:
                            messages.append(message)
                        del buf[:]
Severity: Major
Found in trac/dist.py - About 45 mins to fix

    Function create_zipinfo has 6 arguments (exceeds 4 allowed). Consider refactoring.
    Open

    def create_zipinfo(filename, mtime=None, dir=False, executable=False, symlink=False,
    Severity: Minor
    Found in trac/util/__init__.py - About 45 mins to fix

      Function add has 6 arguments (exceeds 4 allowed). Consider refactoring.
      Open

          def add(cls, env, sid, authenticated, class_, realm, targets):
      Severity: Minor
      Found in trac/notification/model.py - About 45 mins to fix

        Function __init__ has 6 arguments (exceeds 4 allowed). Consider refactoring.
        Open

            def __init__(self, cols, replace_whitespace=0, break_long_words=0,
        Severity: Minor
        Found in trac/util/text.py - About 45 mins to fix

          Function _download_as_zip has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

              def _download_as_zip(self, req, parent, attachments=None):
                  if attachments is None:
                      attachments = self.viewable_attachments(web_context(req, parent))
                  total_size = sum(attachment.size for attachment in attachments)
                  if total_size > self.max_zip_size:
          Severity: Minor
          Found in trac/attachment.py - 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

          Function escape has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

          def escape(text, quotes=True):
              """Create a Markup instance from a string and escape special characters
              it may contain (<, >, & and \").
          
              :param text: the string to escape; if not a string, it is assumed that
          Severity: Minor
          Found in trac/util/html.py - 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

          Function __call__ has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

              def __call__(self, *args, **kwargs):
                  if kwargs:
                      d = self._dict_from_kwargs(kwargs)
                      if d:
                          if self.attrib:
          Severity: Minor
          Found in trac/util/html.py - 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

          Function to_utf8 has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
          Open

          def to_utf8(text, charset='latin1'):
              """Convert input to a UTF-8 `bytes` object.
          
              If the input is not an `str` object, we assume the encoding is
              already UTF-8, ISO Latin-1, or as specified by the optional
          Severity: Minor
          Found in trac/util/text.py - 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

          Avoid deeply nested control flow statements.
          Open

                                  while index >= len(messages):
                                      messages.append(None)
                                  messages[index - 1] = message
          Severity: Major
          Found in trac/dist.py - About 45 mins to fix

            Function _from_database has 6 arguments (exceeds 4 allowed). Consider refactoring.
            Open

                def _from_database(self, id, sid, authenticated, class_, realm, target):
            Severity: Minor
            Found in trac/notification/model.py - About 45 mins to fix

              Function _do_install has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
              Open

                  def _do_install(self, req):
                      """Install a plugin."""
                      if 'plugin_file' not in req.args:
                          raise TracError(_("No file uploaded"))
                      upload = req.args['plugin_file']
              Severity: Minor
              Found in trac/admin/web_ui.py - 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

              Avoid deeply nested control flow statements.
              Open

                                  if dt.month < 12:
                                      dt = dt.replace(month=dt.month + 1)
                                  else:
                                      dt = dt.replace(year=dt.year + 1, month=1)
                              elif start == 'year':
              Severity: Major
              Found in trac/util/datefmt.py - About 45 mins to fix

                Avoid deeply nested control flow statements.
                Open

                                        if name not in func_kwargs_map:
                                            continue
                                        index = func_kwargs_map[name]
                Severity: Major
                Found in trac/dist.py - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                      if dt.month > 1:
                                          dt = dt.replace(month=dt.month - 1)
                                      else:
                                          dt = dt.replace(year=dt.year - 1, month=12)
                                  elif start == 'year':
                  Severity: Major
                  Found in trac/util/datefmt.py - About 45 mins to fix

                    Function groupattr_filter has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                    def groupattr_filter(_eval_ctx, iterable, num, attr, *args, **kwargs):
                    Severity: Minor
                    Found in trac/util/presentation.py - About 45 mins to fix

                      Avoid deeply nested control flow statements.
                      Open

                                              if left_space < w:
                                                  break
                                              left_space -= w
                      Severity: Major
                      Found in trac/util/text.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                            if info[k] == 'UNKNOWN':
                                                info[k] = ''
                                            else:
                                                # Must be encoded as unicode as otherwise Genshi
                                                # may raise a "UnicodeDecodeError".
                        Severity: Major
                        Found in trac/loader.py - About 45 mins to fix

                          Function reset_db has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                              def reset_db(self, default_data=None):
                                  """Remove all data from Trac tables, keeping the tables themselves.
                          
                                  :param default_data: after clean-up, initialize with default data
                                  :return: True upon success
                          Severity: Minor
                          Found in trac/test.py - 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

                          Function destroy_db has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                          Open

                              def destroy_db(self, path, log=None, params={}):
                                  if path != ':memory:':
                                      if not os.path.isabs(path):
                                          path = os.path.join(self.env.path, path)
                                      try:
                          Severity: Minor
                          Found in trac/db/sqlite_backend.py - 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

                          Avoid deeply nested control flow statements.
                          Open

                                                  if col.auto_increment:
                                                      db.update_sequence(cursor, new_table.name,
                                                                         col.name)
                                              self.drop_tables((temp_table_name,))
                          Severity: Major
                          Found in trac/db/api.py - About 45 mins to fix
                            Severity
                            Category
                            Status
                            Source
                            Language