Sign upLogin

ARM-software/golang-utils

View on GitHub
Star

Showing 78 of 97 total issues

Function copyFolderBetweenFSWithExclusionRegexes has a Cognitive Complexity of 13 (exceeds 5 allowed). Consider refactoring.
Open

func copyFolderBetweenFSWithExclusionRegexes(ctx context.Context, srcFs FS, src string, destFs FS, dest string, exclusionSrcFsRegexes []*regexp.Regexp, exclusionDestFsRegexes []*regexp.Regexp) (err error) {
    if IsPathExcluded(src, exclusionSrcFsRegexes...) || IsPathExcluded(dest, exclusionDestFsRegexes...) {
        return
    }
    err = parallelisation.DetermineContextError(ctx)
Severity: Minor
Found in utils/filesystem/files.go - 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

Method pathValidationRule.Validate has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func (r *pathValidationRule) Validate(value interface{}) error {
    err := validation.Required.When(r.condition).Validate(value)
    if err != nil {
        return fmt.Errorf("%w: path [%v] is required: %v", commonerrors.ErrUndefined, value, err.Error())
    }
Severity: Minor
Found in utils/filesystem/filepath.go - 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

Method AbstractStreamPaginator.HasNext has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func (s *AbstractStreamPaginator) HasNext() bool {
    if s.AbstractPaginator.HasNext() {
        s.timeReachLast.Store(time.Now())
        return true
    }
Severity: Minor
Found in utils/collection/pagination/stream.go - 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 FindInSlice has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func FindInSlice(strict bool, slice []string, val ...string) (int, bool) {
    if len(val) == 0 || len(slice) == 0 {
        return -1, false
    }
Severity: Minor
Found in utils/collection/search.go - 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

Method multiplemarshallingError.SetWrappedError has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func (m *multiplemarshallingError) SetWrappedError(err error) {
    if err == nil {
        return
    }
    if x, ok := err.(interface{ Unwrap() []error }); ok {
Severity: Minor
Found in utils/commonerrors/serialisation.go - 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 ListDirTreeWithContextAndExclusionPatterns has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func ListDirTreeWithContextAndExclusionPatterns(ctx context.Context, fs FS, dirPath string, list *[]string, regexes []*regexp.Regexp) (err error) {
    err = parallelisation.DetermineContextError(ctx)
    if err != nil {
        return
    }
Severity: Minor
Found in utils/filesystem/files.go - 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

Method VFS.garbageCollectDir has a Cognitive Complexity of 12 (exceeds 5 allowed). Consider refactoring.
Open

func (fs *VFS) garbageCollectDir(ctx context.Context, durationSinceLastAccess time.Duration, path string, deletePath bool) (err error) {
    err = fs.checkWhetherUnderlyingResourceIsClosed()
    if err != nil {
        return
    }
Severity: Minor
Found in utils/filesystem/files.go - 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 InheritsFrom has 60 lines of code (exceeds 50 allowed). Consider refactoring.
Open

func InheritsFrom(object interface{}, parentType reflect.Type) bool {
    if parentType == nil {
        return object == nil
    }
    r := reflect.ValueOf(object)
Severity: Minor
Found in utils/reflection/reflection.go - About 1 hr to fix

    Function GenerateMockStream has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func GenerateMockStream() (firstPage IStream, itemTotal int64, err error) {
    random := rand.New(rand.NewSource(time.Now().Unix())) //nolint:gosec //causes G404: Use of weak random number generator (math/rand instead of crypto/rand) (gosec), So disable gosec as this is just for testing
    n := random.Intn(50)                                  //nolint:gosec //causes G404: Use of weak random number generator (math/rand instead of crypto/rand) (gosec), So disable gosec as this is just for testing
    var future IStream
    for i := 0; i < n; i++ {
    Severity: Minor
    Found in utils/collection/pagination/testing.go - 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

    Method VFS.ReadFileContent has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func (fs *VFS) ReadFileContent(ctx context.Context, file File, limits ILimits) (content []byte, err error) {
    err = fs.checkWhetherUnderlyingResourceIsClosed()
    if err != nil {
        return
    }
    Severity: Minor
    Found in utils/filesystem/files.go - 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

    Method VFS.unzipZippedFile has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func (fs *VFS) unzipZippedFile(ctx context.Context, dest string, zippedFile *zip.File, limits ILimits, currentDepth int64) (fileSizeOnDisk int64, err error) {
    err = parallelisation.DetermineContextError(ctx)
    if err != nil {
        return
    }
    Severity: Minor
    Found in utils/filesystem/zip.go - 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 RunActionWithParallelCheck has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func RunActionWithParallelCheck(ctx context.Context, action func(ctx context.Context) error, checkAction func(ctx context.Context) bool, checkPeriod time.Duration) error {
    err := DetermineContextError(ctx)
    if err != nil {
        return err
    }
    Severity: Minor
    Found in utils/parallelisation/parallelisation.go - 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

    Method AbstractSharedCacheRepository.getEntryAge has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func (c *AbstractSharedCacheRepository) getEntryAge(ctx context.Context, key string, getCachedPackageFromEntryPath func(ctx context.Context, key, entryDir string) (string, error)) (age time.Duration, err error) {
    err = parallelisation.DetermineContextError(ctx)
    if err != nil {
        return
    }
    Severity: Minor
    Found in utils/sharedcache/common.go - 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 killChildren has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func killChildren(ctx context.Context, p *process.Process) (err error) {
    err = parallelisation.DetermineContextError(ctx)
    if err != nil {
        return
    }
    Severity: Minor
    Found in utils/proc/process.go - 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 GenerateMockCollection has a Cognitive Complexity of 11 (exceeds 5 allowed). Consider refactoring.
    Open

    func GenerateMockCollection() (firstPage IStream, itemTotal int64, err error) {
    random := rand.New(rand.NewSource(time.Now().Unix())) //nolint:gosec //causes G404: Use of weak random number generator (math/rand instead of crypto/rand) (gosec), So disable gosec as this is just for testing
    n := random.Intn(50)                                  //nolint:gosec //causes G404: Use of weak random number generator (math/rand instead of crypto/rand) (gosec), So disable gosec as this is just for testing
    var next IStream
    for i := 0; i < n; i++ {
    Severity: Minor
    Found in utils/collection/pagination/testing.go - 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 CopyBetweenFSWithExclusionRegexes has 54 lines of code (exceeds 50 allowed). Consider refactoring.
    Open

    func CopyBetweenFSWithExclusionRegexes(ctx context.Context, srcFs FS, src string, destFs FS, dest string, exclusionSrcFsRegexes []*regexp.Regexp, exclusionDestFsRegexes []*regexp.Regexp) (err error) {
    if IsPathExcluded(src, exclusionSrcFsRegexes...) || IsPathExcluded(dest, exclusionDestFsRegexes...) {
        return
    }
    err = parallelisation.DetermineContextError(ctx)
    Severity: Minor
    Found in utils/filesystem/files.go - About 1 hr to fix

      Method VFS.SubDirectoriesWithContextAndExclusionPatterns has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      func (fs *VFS) SubDirectoriesWithContextAndExclusionPatterns(ctx context.Context, directory string, exclusionPatterns ...string) (directories []string, err error) {
    err = fs.checkWhetherUnderlyingResourceIsClosed()
    if err != nil {
        return
    }
      Severity: Minor
      Found in utils/filesystem/files.go - 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

      Method VFS.CleanDirWithContextAndExclusionPatterns has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      func (fs *VFS) CleanDirWithContextAndExclusionPatterns(ctx context.Context, dir string, exclusionPatterns ...string) (err error) {
    err = fs.checkWhetherUnderlyingResourceIsClosed()
    if err != nil {
        return
    }
      Severity: Minor
      Found in utils/filesystem/files.go - 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

      Method RemoteLockFile.Lock has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      func (l *RemoteLockFile) Lock(ctx context.Context) error {
    for {
        if err := parallelisation.DetermineContextError(ctx); err != nil {
            return err
        }
      Severity: Minor
      Found in utils/filesystem/lockfile.go - 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

      Method VFS.CopyToFileWithContext has a Cognitive Complexity of 10 (exceeds 5 allowed). Consider refactoring.
      Open

      func (fs *VFS) CopyToFileWithContext(ctx context.Context, src string, dest string) (err error) {
    err = fs.checkWhetherUnderlyingResourceIsClosed()
    if err != nil {
        return
    }
      Severity: Minor
      Found in utils/filesystem/files.go - 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

      Severity
      Category
      Status
      Source
      Language