edgewall/trac

View on GitHub

Showing 1,372 of 1,372 total issues

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

def milestone_stats_data(env, req, stat, name, grouped_by='component',
Severity: Minor
Found in trac/ticket/roadmap.py - About 45 mins to fix

    Avoid deeply nested control flow statements.
    Open

                                if not word:
                                    continue
                            clauses.append("COALESCE(%s,'') %s%s" % (col, cneg,
    Severity: Major
    Found in trac/ticket/query.py - About 45 mins to fix

      Avoid deeply nested control flow statements.
      Open

                              for name in sel:
                                  model.Version(self.env, name).delete()
                                  if name == default:
                                      self.config.set('ticket',
                                                      'default_version', '')
      Severity: Major
      Found in trac/ticket/admin.py - About 45 mins to fix

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

            def _send_csv(self, req, cols, rows, sep=',', mimetype='text/plain',
        Severity: Minor
        Found in trac/ticket/report.py - About 45 mins to fix

          Avoid deeply nested control flow statements.
          Open

                                  if field == 'description':
                                      new_descr = wrap(new, self.COLS, ' ', ' ', '\n',
                                                       self.ambiwidth)
                                      old_descr = wrap(old, self.COLS, '> ', '> ', '\n',
                                                       self.ambiwidth)
          Severity: Major
          Found in trac/ticket/notification.py - About 45 mins to fix

            Avoid deeply nested control flow statements.
            Open

                                    for enum in self._enum_cls.select(self.env):
                                        new_value = order[enum.value]
                                        if new_value != enum.value:
                                            enum.value = new_value
                                            enum.update()
            Severity: Major
            Found in trac/ticket/admin.py - About 45 mins to fix

              Avoid deeply nested control flow statements.
              Open

                                      if ends:
                                          vals = [start + '..' + end
                                                  for (start, end) in zip(vals, ends)]
                                  if k in remove_constraints:
              Severity: Major
              Found in trac/ticket/query.py - About 45 mins to fix

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

                    def _query_link(self, req, name, value, text=None, class_=None, query=None):
                Severity: Minor
                Found in trac/ticket/web_ui.py - About 45 mins to fix

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

                      def get_available_actions(self, req, ticket):
                          """Returns a sorted list of available actions"""
                          # The list should not have duplicates.
                          actions = {}
                          for controller in self.action_controllers:
                  Severity: Minor
                  Found in trac/ticket/api.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 0 <= idx < len(vals):
                                              del vals[idx]
                                              if not vals:
                                                  continue
                                          else:
                  Severity: Major
                  Found in trac/ticket/query.py - About 45 mins to fix

                    Avoid deeply nested control flow statements.
                    Open

                                            if cnum == 'description':
                                                title = _("Description for #%(id)s: %(summary)s",
                                                          id=resource.id, summary=summary)
                                            else:
                                                title = _("Comment %(cnum)s for #%(id)s: "
                    Severity: Major
                    Found in trac/ticket/api.py - About 45 mins to fix

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

                          def execute_paginated_report(self, req, id, sql, args, limit=0, offset=0):
                      Severity: Minor
                      Found in trac/ticket/report.py - About 45 mins to fix

                        Avoid deeply nested control flow statements.
                        Open

                                                with self.env.db_query as db:
                                                    for name, value in db(
                                                            "SELECT name, %s FROM enum WHERE type=%%s"
                                                            % db.cast('value', 'int'),
                                                            (sort_col,)):
                        Severity: Major
                        Found in trac/ticket/report.py - About 45 mins to fix

                          Avoid deeply nested control flow statements.
                          Open

                                                  for name in sel:
                                                      model.Component(self.env, name).delete()
                                                      if name == default:
                                                          self.config.set('ticket',
                                                                          'default_component', '')
                          Severity: Major
                          Found in trac/ticket/admin.py - About 45 mins to fix

                            Avoid deeply nested control flow statements.
                            Open

                                                    for name in sel:
                                                        milestone = model.Milestone(self.env, name)
                                                        milestone.move_tickets(None, req.authname,
                                                                               "Milestone deleted")
                                                        milestone.delete()
                            Severity: Major
                            Found in trac/ticket/admin.py - About 45 mins to fix

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

                                  def _render_property_diff(self, req, ticket, field, old, new,
                              Severity: Minor
                              Found in trac/ticket/web_ui.py - About 45 mins to fix

                                Avoid deeply nested control flow statements.
                                Open

                                                            if a == b:
                                                                ids.append(str(a))
                                                            else:
                                                                id_clauses.append('t.id BETWEEN %s AND %s')
                                                                args.append(a)
                                Severity: Major
                                Found in trac/ticket/query.py - About 45 mins to fix

                                  Avoid deeply nested control flow statements.
                                  Open

                                                          for next_id, in db(
                                                                  "SELECT min(id) FROM ticket WHERE %s < id",
                                                                  (ticket.id,)):
                                                              add_ticket_link('next', int(next_id))
                                                      break
                                  Severity: Major
                                  Found in trac/ticket/web_ui.py - About 45 mins to fix

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

                                        def __init__(self, path, params, log):
                                            self.log = log
                                            self.pool = Pool()
                                    
                                            # note that this should usually not happen (str arg expected)
                                    Severity: Minor
                                    Found in tracopt/versioncontrol/svn/svn_fs.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 expand_macro has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                                    Open

                                        def expand_macro(self, formatter, name, content, args=None):
                                            args = args or {}
                                            reponame = args.get('repository') or ''
                                            rev = args.get('revision')
                                            repos = RepositoryManager(self.env).get_repository(reponame)
                                    Severity: Minor
                                    Found in tracopt/ticket/commit_updater.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

                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language