Genese complexity report

<- cyclomatic-cpx.service.ts
Methods : 4
Complexity index : 17.7
Cyclomatic complexity : 5
Cognitive complexity
100 % Correct 4/4
0 % Warning 0/4 (threshold : 10)
0 % Error 0/4 (threshold : 20)
Cyclomatic complexity
100 % Correct 4/4
0 % Warning 0/4 (threshold : 5)
0 % Error 0/4 (threshold : 10)
Methods of cyclomatic-cpx.service.ts
calculateCyclomaticCpx Complexity Index 3.5 Cyclomatic complexity 1
                            
                                
            
            
            
                /**
                 * Returns the cyclomatic complexity of an AST node, including its children
                 * @param astNode
                 */
                static calculateCyclomaticCpx(astNode: AstNode): number { // ---------------------------------- +0.3 Complexity index (+0.3 atomic)
                    let totalComplexity = CyclomaticCpxService.currentAstNodeCyclomaticCpx(astNode); // ------- +1.5 Complexity index (+0.5 atomic, +1 structural)
                    totalComplexity += CyclomaticCpxService.childrenCyclomaticCpx(astNode); // ---------------- +1.5 Complexity index (+0.5 atomic, +1 structural)
                    return totalComplexity; // ---------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                }
            
                            
                        
currentAstNodeCyclomaticCpx Complexity Index 3 Cyclomatic complexity 1
                            
                                
                
            
            
                /**
                 * Returns the cyclomatic complexity of an AST node, without its children
                 * @param astNode
                 */
                private static currentAstNodeCyclomaticCpx(astNode: AstNode): number { // ---------------- +0.3 Complexity index (+0.3 atomic)
                    return CyclomaticCpxService.increasesCyclomaticComplexity(astNode) ? 1 : 0; // ------- +2.7 Complexity index (+0.7 atomic, +2 structural)
                }
            
                            
                        
childrenCyclomaticCpx Complexity Index 5.2 Cyclomatic complexity 2
                            
                                
                
            
            
                /**
                 * Returns the cyclomatic complexity of the children of an AST node
                 * @param astNode
                 */
                private static childrenCyclomaticCpx(astNode: AstNode): number { // ------------------------------- +0.3 Complexity index (+0.3 atomic)
                    let cyclomaticCpx = 0; // --------------------------------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                    for (const childAstNode of astNode.children) { // --------------------------------------------- +1.4 Complexity index (+0.4 atomic, +1 structural)
                        cyclomaticCpx += CyclomaticCpxService.currentAstNodeCyclomaticCpx(childAstNode); // ------- +1.5 Complexity index (+0.5 atomic, +1 structural)
                        cyclomaticCpx += CyclomaticCpxService.childrenCyclomaticCpx(childAstNode) // -------------- +1.5 Complexity index (+0.5 atomic, +1 structural)
                    }
                    return cyclomaticCpx; // ---------------------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                }
            
                            
                        
increasesCyclomaticComplexity Complexity Index 6 Cyclomatic complexity 1
                            
                                
                
            
            
                /**
                 * Increases the cyclomatic complexity when the AST node must increase it
                 * @param astNode
                 */
                static increasesCyclomaticComplexity(astNode: AstNode): boolean { // --------------- +0.3 Complexity index (+0.3 atomic)
                    switch (astNode.kind) { // ----------------------------------------------------- +1.3 Complexity index (+0.3 atomic, +1 structural)
                        case SyntaxKind.AmpersandAmpersandToken: // -------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.BarBarToken: // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.CaseClause: // --------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.CatchClause: // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.DoStatement: // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.ForStatement: // ------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.ForInStatement: // ----------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.ForOfStatement: // ----------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.FunctionDeclaration: // ------------------------------------ +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.IfStatement: // -------------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.MethodDeclaration: // -------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.QuestionDotToken: // --------------------------------------- +0.3 Complexity index (+0.3 atomic)
                        case SyntaxKind.WhileStatement: // ----------------------------------------- +0.3 Complexity index (+0.3 atomic)
                            return true; // -------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                        default: // ---------------------------------------------------------------- +0.1 Complexity index (+0.1 atomic)
                            return false; // ------------------------------------------------------- +0.2 Complexity index (+0.2 atomic)
                    }
                }