Chalarangelo/30-seconds-of-code

View on GitHub

Showing 19 of 4,226 total issues

File globals.js has 816 lines of code (exceeds 250 allowed). Consider refactoring.
Open

export default {
  __dirname: false,
  __filename: false,
  AbortController: false,
  AbortSignal: false,
Severity: Major
Found in globals.js - About 1 day to fix

    File application.js has 429 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    import { Glob } from 'glob';
    import chalk from 'chalk';
    import repl from 'node:repl';
    import util from 'node:util';
    import jsiqle from '@jsiqle/core';
    Severity: Minor
    Found in src/blocks/application.js - About 6 hrs to fix

      Function populateDataset has 135 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

        static populateDataset({ quiet = false } = {}) {
          const logger = new Logger('Application.populateDataset', { muted: quiet });
          logger.log('Populating dataset...');
          const {
            Snippet,
      Severity: Major
      Found in src/blocks/application.js - About 5 hrs to fix

        Application has 32 functions (exceeds 20 allowed). Consider refactoring.
        Open

        export class Application {
          // -------------------------------------------------------------
          // Static module getters
          // -------------------------------------------------------------
          // These modules are not expected to change during the lifetime of the
        Severity: Minor
        Found in src/blocks/application.js - About 4 hrs to fix

          Function stem has a Cognitive Complexity of 26 (exceeds 5 allowed). Consider refactoring.
          Open

          const stem = str => {
            // Exit early
            if (str.length < 3) return str;
          
            let firstCharacterWasLowerCaseY;
          Severity: Minor
          Found in src/utils/search.js - 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

          File searchEngine.js has 291 lines of code (exceeds 250 allowed). Consider refactoring.
          Open

          export default {
            serverStopWords: [
              'a',
              'about',
              'above',
          Severity: Minor
          Found in src/settings/searchEngine.js - About 3 hrs to fix

            File snippet.js has 259 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            import { convertToSeoSlug, uniqueElements, stripMarkdownFormat } from '#utils';
            import { Ranker } from '#blocks/utilities/ranker';
            import { Recommender } from '#blocks/utilities/recommender';
            import { TagFormatter } from '#blocks/utilities/tagFormatter';
            import { TocReader } from '#blocks/utilities/tocReader';
            Severity: Minor
            Found in src/blocks/models/snippet.js - About 2 hrs to fix

              File extractor.js has 254 lines of code (exceeds 250 allowed). Consider refactoring.
              Open

              /* eslint-disable no-unused-vars */
              import pathSettings from '#settings/paths';
              import { Logger } from '#blocks/utilities/logger';
              import { TextParser } from '#blocks/extractor/textParser';
              import { MarkdownParser } from '#blocks/extractor/markdownParser/markdownParser';
              Severity: Minor
              Found in src/blocks/extractor/extractor.js - About 2 hrs to fix

                File preparedQueries.js has 252 lines of code (exceeds 250 allowed). Consider refactoring.
                Open

                import settings from '#settings/global';
                import { globSync } from 'glob';
                import { YAMLHandler } from '#blocks/utilities/yamlHandler';
                import { CSVHandler } from '#blocks/utilities/csvHandler';
                
                
                Severity: Minor
                Found in src/blocks/utilities/preparedQueries.js - About 2 hrs to fix

                  Function stem has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  const stem = str => {
                    // Exit early
                    if (str.length < 3) return str;
                  
                    let firstCharacterWasLowerCaseY;
                  Severity: Minor
                  Found in src/utils/search.js - About 1 hr to fix

                    Function write has 41 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                      static write(application, { quiet = false } = {}) {
                        const logger = new Logger('PageWriter.write', { muted: quiet });
                    
                        const { dataset } = application;
                    
                    
                    Severity: Minor
                    Found in src/blocks/writers/pageWriter.js - About 1 hr to fix

                      Function props has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          props: page => {
                            const collection = page.collection;
                            const context = {};
                      
                            context.slug = page.slug;
                      Severity: Minor
                      Found in src/blocks/models/pages/collectionPage.js - About 1 hr to fix

                        Function props has 38 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            props: page => {
                              const context = {};
                        
                              context.slug = page.slug;
                              context.pageDescription = page.shortDescription;
                        Severity: Minor
                        Found in src/blocks/models/pages/collectionsPage.js - About 1 hr to fix

                          Function setupReplCommands has 35 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            static setupReplCommands() {
                              const logger = new Logger('Application.setupReplCommands');
                              logger.log('Setting up REPL commands...');
                          
                              const replServer = Application._replServer;
                          Severity: Minor
                          Found in src/blocks/application.js - About 1 hr to fix

                            Function startRepl has 32 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                              static startRepl() {
                                const logger = new Logger('Application.startRepl');
                                logger.log('Starting REPL...');
                            
                                Application._replServer = repl.start({
                            Severity: Minor
                            Found in src/blocks/application.js - About 1 hr to fix

                              Function searchByKeyphrase has 31 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                searchByKeyphrase(keyphrase) {
                                  let q = keyphrase.toLowerCase().trim();
                                  if (q.length <= 1) return [];
                                  let results = [];
                                  if (q.length) {
                              Severity: Minor
                              Found in src/components/Omnisearch.js - About 1 hr to fix

                                Function body has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                      body: snippet => {
                                        if (!snippet.hasCollection) return [];
                                
                                        const ids = [];
                                        if (snippet.orderedCollections[0]) {
                                Severity: Minor
                                Found in src/blocks/models/snippet.js - About 35 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 debug has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                                Open

                                  static debug(msg, printTrace = false) {
                                    const header = Logger._headerLine(msg, 'debug', 'Logger.debug');
                                
                                    let _msg;
                                    if (typeof msg === 'string') _msg = msg;
                                Severity: Minor
                                Found in src/blocks/utilities/logger.js - About 35 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 body has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                Open

                                      body: snippet => {
                                        const orderedCollections = [];
                                
                                        const primaryCollections = snippet.collections.primary;
                                        const allSecondaryCollections = snippet.collections.secondary;
                                Severity: Minor
                                Found in src/blocks/models/snippet.js - About 25 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

                                Severity
                                Category
                                Status
                                Source
                                Language