gocognit

package module
v1.1.6 Latest Latest
Warning

This package is not in the latest version of its module.

Go to latest
Published: Apr 10, 2022 License: MIT Imports: 7 Imported by: 0

README

GoDoc fork: github.com/uudashr/gocognit

Gocognit

Gocognit calculates cognitive complexities of functions in Go source code. A measurement of how hard does the code is intuitively to understand.

Understanding the complexity

Given code using if statement,

func GetWords(number int) string {
    if number == 1 {            // +1
        return "one"
    } else if number == 2 {     // +1
        return "a couple"
    } else if number == 3 {     // +1
        return "a few"
    } else {                    // +1
        return "lots"
    }
} // Cognitive complexity = 4

Above code can be refactored using switch statement,

func GetWords(number int) string {
    switch number {             // +1
        case 1:
            return "one"
        case 2:
            return "a couple"
        case 3:
            return "a few"
        default:
            return "lots"
    }
} // Cognitive complexity = 1

As you see above codes are the same, but the second code are easier to understand, that is why the cognitive complexity score are lower compare to the first one.

Comparison with cyclometic complexity

Example 1
Cyclometic complexity
func GetWords(number int) string {      // +1
    switch number {
        case 1:                         // +1
            return "one"
        case 2:                         // +1
            return "a couple"
        case 3:                         // +1
             return "a few"
        default:
             return "lots"
    }
} // Cyclomatic complexity = 4
Cognitive complexity
func GetWords(number int) string {
    switch number {                     // +1
        case 1:
            return "one"
        case 2:
            return "a couple"
        case 3:
            return "a few"
        default:
            return "lots"
    }
} // Cognitive complexity = 1

Cognitive complexity give lower score compare to cyclomatic complexity.

Example 2
Cyclomatic complexity
func SumOfPrimes(max int) int {         // +1
    var total int

OUT:
    for i := 1; i < max; i++ {          // +1
        for j := 2; j < i; j++ {        // +1
            if i%j == 0 {               // +1
                continue OUT
            }
        }
        total += i
    }

    return total
} // Cyclomatic complexity = 4
Cognitive complexity
func SumOfPrimes(max int) int {
    var total int

OUT:
    for i := 1; i < max; i++ {          // +1
        for j := 2; j < i; j++ {        // +2 (nesting = 1)
            if i%j == 0 {               // +3 (nesting = 2)
                continue OUT            // +1
            }
        }
        total += i
    }

    return total
} // Cognitive complexity = 7

Cognitive complexity give higher score compare to cyclomatic complexity.

Rules

The cognitive complexity of a function is calculated according to the following rules:

Note: these rules are specific for Go, please see the original whitepaper for more complete reference. Example: these example are specific for Go, please see the example/example.go for more complete reference.

Increments

There is an increment for each of the following:

  1. if, else if, else
  2. switch, select
  3. for
  4. goto LABEL, break LABEL, continue LABEL
  5. sequence of binary logical operators
  6. each method in a recursion cycle
Nesting level

The following structures increment the nesting level:

  1. if, else if, else
  2. switch, select
  3. for
  4. function literal or lambda
Nesting increments

The following structures receive a nesting increment commensurate with their nested depth inside nesting structures:

  1. if
  2. switch, select
  3. for

Installation

$ go install github.com/distroy/gocognit/cmd/gocognit@latest

or

$ go get github.com/distroy/gocognit/cmd/gocognit

Usage

$ gocognit -h
Calculate cognitive complexities of Go functions.
Usage:
        gocognit [flags] <Go file or directory> ...
<Go file or directory>:
        default current directory
Flags:
        -over <N>   show functions with complexity > N only and
                    return exit code 1 if the set is non-empty
        -top <N>    show the top N most complex functions only
        -avg        show the average complexity over all functions,
                    not depending on whether -over or -top are set
        -include <regexp>
                    the regexp for include pathes
        -exclude <regexp>
                    the regexp for exclude pathes
                    default:
                        ^vendor/
                        /vendor/
                        \.pb\.go$

The output fields for each line are:
<complexity> <package> <function> <file:begin_row,end_row>

The document of cognitive complexity:
https://sonarsource.com/docs/CognitiveComplexity.pdf

Examples:

$ gocognit .
$ gocognit main.go
$ gocognit -top 10 src/
$ gocognit -over 25 docker
$ gocognit -avg .

The output fields for each line are:

<complexity> <package> <function> <file:begin_row,end_row>

Documentation

Overview

Package gocognit defines Analyzer other utilities to checks and calculate the complexity of function based on "cognitive complexity" methods.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func Complexity

func Complexity(fset *token.FileSet, fn *ast.FuncDecl) int

Complexity calculates the cognitive complexity of a function.

func SetDebug added in v1.1.3

func SetDebug(enable bool)

Types

type Stat

type Stat struct {
	PkgName    string
	FuncName   string
	Complexity int
	BeginPos   token.Position
	EndPos     token.Position
}

Stat is statistic of the complexity.

func ComplexityStats

func ComplexityStats(f *ast.File, fset *token.FileSet, stats []Stat) []Stat

ComplexityStats builds the complexity statistics.

func (Stat) String

func (s Stat) String() string

Directories

Path Synopsis
cmd
gocognit
GoCognitive calculates the cognitive complexities of functions and methods in Go source code.
GoCognitive calculates the cognitive complexities of functions and methods in Go source code.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL