kiwitcms/Kiwi

View on GitHub

Showing 112 of 403 total issues

Function pageTestrunsMutableReadyHandler has 30 lines of code (exceeds 25 allowed). Consider refactoring.
Open

export function pageTestrunsMutableReadyHandler () {
    initializeDateTimePicker('#id_planned_start')
    initializeDateTimePicker('#id_planned_stop')

    $('#add_id_product').click(function () {
Severity: Minor
Found in tcms/testruns/static/testruns/js/mutable.js - About 1 hr to fix

    Function pageTestplansMutableReadyHandler has 29 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    export function pageTestplansMutableReadyHandler () {
        if ($('#id_version').find('option').length === 0) {
            populateVersion()
        }
    
    
    Severity: Minor
    Found in tcms/testplans/static/testplans/js/mutable.js - About 1 hr to fix

      Function preProcessData has 29 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function preProcessData (data, callbackF) {
          const runIds = []
          const productIds = []
          data.forEach(function (element) {
              runIds.push(element.id)
      Severity: Minor
      Found in tcms/testruns/static/testruns/js/search.js - About 1 hr to fix

        Function pageBugsMutableReadyHandler has 29 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        export function pageBugsMutableReadyHandler () {
            $('#add_id_product').click(function () {
                return showRelatedObjectPopup(this)
            })
        
        
        Severity: Minor
        Found in tcms/bugs/static/bugs/js/mutable.js - About 1 hr to fix

          Function ajax has 28 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

                  ajax: function (data, callbackF, settings) {
                      const params = {}
          
                      if ($('#id_name').val()) {
                          params.name__icontains = $('#id_name').val()
          Severity: Minor
          Found in tcms/testplans/static/testplans/js/search.js - About 1 hr to fix

            Function create_permissions has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
            Open

            def create_permissions(
                app_config,
                verbosity=2,
                interactive=True,
                using=DEFAULT_DB_ALIAS,
            Severity: Minor
            Found in tcms/bugs/management.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 drawTable has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
            Open

            export function drawTable () {
                $('.js-spinner').show()
                if (table) {
                    table.destroy()
            
            
            Severity: Minor
            Found in tcms/telemetry/static/telemetry/js/testing/status-matrix.js - 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 parse_translation_string has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
            Open

                def parse_translation_string(self, filename, lines):
                    startline = 0
                    startcol = 0
                    blocktrans_string = ""
            
            
            Severity: Minor
            Found in kiwi_lint/similar_string.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 filterTestExecutionsByProperty has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
            Open

            function filterTestExecutionsByProperty (runId, executions, filterBy, filterValue) {
                // no input => show all rows
                if (filterValue.trim().length === 0) {
                    $('.test-execution-element').show()
                    $('.test-executions-count').text(executions.length)
            Severity: Minor
            Found in tcms/testruns/static/testruns/js/get.js - 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 visit_call has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
            Open

                def visit_call(self, node):
                    if node.func.as_string().endswith("Field") and node.keywords:
                        for keyword in node.keywords:
                            if keyword.arg == "label":
                                self.add_message("form-field-label-used", node=node)
            Severity: Minor
            Found in kiwi_lint/forms.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 renderTestExecutionRow has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function renderTestExecutionRow (testExecution) {
                // refresh the internal data structure b/c some fields are used
                // to render the expand area and may have changed via bulk-update meanwhile
                testExecution.status__name = $('#test_run_pk').data(`trans-execution-status-${testExecution.status}`)
                allExecutions[testExecution.id] = testExecution
            Severity: Minor
            Found in tcms/testruns/static/testruns/js/get.js - About 1 hr to fix

              Function advancedSearchAndAddTestCases has 27 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              export function advancedSearchAndAddTestCases (objId, rpcMethod, href, errorMessage) {
                  window.addTestCases = function (testCaseIDs, sender) {
                      let rpcErrors = 0
              
                      // close the popup
              Severity: Minor
              Found in tcms/static/js/utils.js - About 1 hr to fix

                Function jsonRPC has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                export function jsonRPC (rpcMethod, rpcParams, callback, isSync) {
                    // .filter() args are passed as dictionary but other args,
                    // e.g. for .add_tag() are passed as a list of positional values
                    if (!Array.isArray(rpcParams)) {
                        rpcParams = [rpcParams]
                Severity: Minor
                Found in tcms/static/js/jsonrpc.js - About 1 hr to fix

                  Function clone has 8 arguments (exceeds 4 allowed). Consider refactoring.
                  Open

                      def clone(  # pylint: disable=too-many-arguments,too-many-positional-arguments
                  Severity: Major
                  Found in tcms/testplans/models.py - About 1 hr to fix

                    Function mailto has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                    Open

                    def mailto(  # pylint: disable=invalid-name
                        template_name,
                        subject,
                        recipients=None,
                        context=None,
                    Severity: Minor
                    Found in tcms/core/utils/mailto.py - About 55 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 render_change_form has 6 arguments (exceeds 4 allowed). Consider refactoring.
                    Open

                        def render_change_form(
                    Severity: Minor
                    Found in tcms/kiwi_auth/admin.py - About 45 mins to fix

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

                          def _url_view_mapping(cls, root_urlpatterns):
                              def flatten(urlpatterns, prefix="^", result=None):
                                  """
                                  Flattens the url graph
                      
                      
                      Severity: Minor
                      Found in kiwi_lint/views.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 advancedSearchAndAddTestCases has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                      Open

                      export function advancedSearchAndAddTestCases (objId, rpcMethod, href, errorMessage) {
                          window.addTestCases = function (testCaseIDs, sender) {
                              let rpcErrors = 0
                      
                              // close the popup
                      Severity: Minor
                      Found in tcms/static/js/utils.js - 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 create_permissions has 6 arguments (exceeds 4 allowed). Consider refactoring.
                      Open

                      def create_permissions(
                      Severity: Minor
                      Found in tcms/bugs/management.py - About 45 mins to fix

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

                        def mailto(  # pylint: disable=invalid-name
                        Severity: Minor
                        Found in tcms/core/utils/mailto.py - About 45 mins to fix
                          Severity
                          Category
                          Status
                          Source
                          Language