Sign upLogin

mtrevisan/HunLinter

View on GitHub
Star

Showing 338 of 403 total issues

Method disjoinConditions has a Cognitive Complexity of 98 (exceeds 5 allowed). Consider refactoring.
Open

    private synchronized List<LineEntry> disjoinConditions(final List<LineEntry> rules){
        final ArrayList<List<LineEntry>> branches = new ArrayList<>(0);
        final List<LineEntry> finalRules = new ArrayList<>(0);
        final StringBuilder condition = new StringBuilder();
        boolean restart = true;
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/dictionary/RulesReducer.java - About 1 day 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 writeDuplicates has a Cognitive Complexity of 57 (exceeds 5 allowed). Consider refactoring.
Open

    private void writeDuplicates(final File duplicatesFile, final Collection<List<Duplicate>> duplicates){
        final int totalSize = duplicates.size();
        if(totalSize > 0){
            LOGGER.info(ParserManager.MARKER_APPLICATION, "Write results to file (step 3/3)");
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/workers/dictionary/DuplicatesWorker.java - About 1 day 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

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2021-2022 Mauro Trevisan
 * <p>
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/services/system/charsets/ISO8859_14Charset.java and 1 other location - About 7 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/services/system/charsets/ISO8859_10Charset.java on lines 1..115

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 472.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2021-2022 Mauro Trevisan
 * <p>
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/services/system/charsets/ISO8859_10Charset.java and 1 other location - About 7 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/services/system/charsets/ISO8859_14Charset.java on lines 1..114

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 472.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Method applyConversionTable has a Cognitive Complexity of 42 (exceeds 5 allowed). Consider refactoring.
Open

    public final String applyConversionTable(final String word){
        String convertedWord = word;
        if(table != null){
            final String inputWord = StringUtils.replace(word, StringUtils.SPACE, "_");
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/affix/ConversionTable.java - About 6 hrs 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 insert has a Cognitive Complexity of 41 (exceeds 5 allowed). Consider refactoring.
Open

    private int insert(final List<IndexDataPair<RadixTrieNode>> siblings){
        int begin = 0;
        if(!siblings.isEmpty()){
            int checkPos = Math.max(siblings.get(0).getIndex() + 1, nextCheckPos) - 1;
            int nonZeroNum = 0;
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/datastructures/ahocorasicktrie/AhoCorasickTrieBuilder.java - About 6 hrs 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 disjoinDifferentConditionLength has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
Open

    private static List<LineEntry> disjoinDifferentConditionLength(final List<List<LineEntry>> branches, final int branchIndex,
            final Comparator<String> comparator){
        final List<LineEntry> branch = branches.get(branchIndex);
        final LineEntry parent = branch.get(0);
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/dictionary/RulesReducer.java - About 5 hrs 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 generateCompounds has a Cognitive Complexity of 36 (exceeds 5 allowed). Consider refactoring.
Open

    protected final List<List<List<Inflection>>> generateCompounds(final List<List<String>> permutations,
            final Map<String, List<DictionaryEntry>> inputs){
        final List<List<List<Inflection>>> entries = new ArrayList<>(0);
        final Map<String, List<Inflection>> dicEntries = new HashMap<>(0);
        outer:
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/dictionary/generators/WordGeneratorCompound.java - About 5 hrs 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

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2019-2022 Mauro Trevisan
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/actions/DictionaryExtractPoSFSAAction.java and 1 other location - About 5 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/actions/DictionaryExtractWordlistFSAAction.java on lines 1..131

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 335.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2019-2022 Mauro Trevisan
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/actions/DictionaryExtractWordlistFSAAction.java and 1 other location - About 5 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/actions/DictionaryExtractPoSFSAAction.java on lines 1..131

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 335.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Method innerMarkDefaultStress has a Cognitive Complexity of 34 (exceeds 5 allowed). Consider refactoring.
Open

    private static String innerMarkDefaultStress(String word){
        int higherIndex = StringUtils.lastIndexOf(word, '’') - 1;
        final int wordLength = word.length();
        if(higherIndex < 0)
            higherIndex = wordLength - 1;
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/languages/vec/WordVEC.java - About 5 hrs 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

Similar blocks of code found in 2 locations. Consider refactoring.
Open

    public static void createPOSInfo(final AffixData affixData, final String encoder, final Path outputPath, final Charset charset)
            throws IOException{
        final Collection<String> content = new ArrayList<>(Arrays.asList(
            DictionaryAttribute.CREATION_DATE.propertyName + EQUALS + ZonedDateTime.now().format(DateTimeFormatter.ofPattern("u-MM-dd")),
            DictionaryAttribute.SEPARATOR.propertyName + EQUALS + Inflection.POS_FSA_SEPARATOR,
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/builders/MetadataBuilder.java and 1 other location - About 4 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/builders/MetadataBuilder.java on lines 96..117

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 271.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

    public static void createWordlistInfo(final AffixData affixData, final String encoder, final Path outputPath, final Charset charset)
            throws IOException{
        final Collection<String> content = new ArrayList<>(Arrays.asList(
            DictionaryAttribute.CREATION_DATE.propertyName + EQUALS + ZonedDateTime.now().format(DateTimeFormatter.ofPattern("u-MM-dd")),
            DictionaryAttribute.SEPARATOR.propertyName + EQUALS + Inflection.POS_FSA_SEPARATOR,
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/builders/MetadataBuilder.java and 1 other location - About 4 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/builders/MetadataBuilder.java on lines 72..93

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 271.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Method calculateBreakpoints has a Cognitive Complexity of 28 (exceeds 5 allowed). Consider refactoring.
Open

    private static HyphenationBreak calculateBreakpoints(final String word, final AhoCorasickTrie<String> patterns,
            final HyphenationOptions options){
        final int wordSize = word.length();
        final Map<Integer, IndexDataPair<String>> indexesAndRules = new HashMap<>(wordSize);
        if(patterns != null){
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/hyphenation/Hyphenator.java - About 4 hrs 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

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2019-2022 Mauro Trevisan
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/actions/ThesaurusLinterFSAAction.java and 1 other location - About 4 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/actions/AutoCorrectLinterFSAAction.java on lines 1..117

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 255.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 2 locations. Consider refactoring.
Open

/**
 * Copyright (c) 2019-2022 Mauro Trevisan
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
Severity: Major
Found in src/main/java/io/github/mtrevisan/hunlinter/actions/AutoCorrectLinterFSAAction.java and 1 other location - About 4 hrs to fix
src/main/java/io/github/mtrevisan/hunlinter/actions/ThesaurusLinterFSAAction.java on lines 1..117

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 255.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Method applyAffixRule has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
Open

    private List<Inflection> applyAffixRule(final DictionaryEntry dicEntry, final String affix, final List<String> postponedAffixes,
            final boolean isCompound, final RuleEntry overriddenRule) throws NoApplicableRuleException{
        final AffixEntry[] appliedRules = dicEntry.getAppliedRules();

        RuleEntry rule = affixData.getData(affix);
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/dictionary/generators/WordGeneratorBase.java - About 3 hrs 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 perfectHash has a Cognitive Complexity of 25 (exceeds 5 allowed). Consider refactoring.
Open

    public int perfectHash(final byte[] sequence, final int start, final int length, final int node){
        if(!fsa.getFlags().contains(FSAFlags.NUMBERS))
            throw new IllegalArgumentException("FSA not built with NUMBERS option.");

        int hash = 0;
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/lookup/FSATraversal.java - About 3 hrs 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 extractAllAffixes has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
Open

    private List<Inflection> extractAllAffixes(final String word, final String partOfSpeech){
        final List<Inflection> originatingRules = new ArrayList<>(0);
        final DictionaryEntry nullDicEntry = dictionaryEntryFactory.createFromDictionaryLine(word);
        final List<RuleEntry> ruleEntries = affixData.getRuleEntries();
        final Collection<Inflection> originatingRulesFromEntry = new ArrayList<>(0);
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/parsers/dictionary/generators/WordMuncher.java - About 3 hrs 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 emitArcs has a Cognitive Complexity of 24 (exceeds 5 allowed). Consider refactoring.
Open

    private boolean emitArcs(final FSAAbstract fsa, final OutputStream os, final int[] linearized, final int gtl, final int nodeDataLength)
            throws IOException{
        final ByteBuffer bb = ByteBuffer.allocate(Math.max(MAX_NODE_DATA_SIZE, MAX_ARC_SIZE));

        int offset = 0;
Severity: Minor
Found in src/main/java/io/github/mtrevisan/hunlinter/datastructures/fsa/serializers/FSASerializer.java - About 3 hrs 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