lucydot/effmass

View on GitHub

Showing 213 of 291 total issues

Function highlightText has a Cognitive Complexity of 17 (exceeds 5 allowed). Consider refactoring.
Open

jQuery.fn.highlightText = function(text, className) {
  function highlight(node, addItems) {
    if (node.nodeType === 3) {
      var val = node.nodeValue;
      var pos = val.toLowerCase().indexOf(text);
Severity: Minor
Found in docs/build/_static/doctools.js - About 2 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

Function displayNextItem has 56 lines of code (exceeds 25 allowed). Consider refactoring.
Open

    function displayNextItem() {
      // results left, load the summary and display it
      if (results.length) {
        var item = results.pop();
        var listItem = $('<li></li>');
Severity: Major
Found in docs/build/_static/searchtools.js - About 2 hrs to fix

    Function init has 54 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

        init = jQuery.fn.init = function( selector, context, root ) {
            var match, elem;
    
            // HANDLE: $(""), $(null), $(undefined), $(false)
            if ( !selector ) {
    Severity: Major
    Found in docs/build/_static/jquery-3.5.1.js - About 2 hrs to fix

      Function __init__ has 53 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          def __init__(self, directory_path, output_name="calculation.out"):
              r"""
              Initialises an instance of the :class:`~effmass.inputs.DataAims` class and checks data using :meth:`check_data`.
      
              Args:
      Severity: Major
      Found in effmass/inputs.py - About 2 hrs to fix

        Function performObjectSearch has 52 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

          performObjectSearch : function(object, otherterms) {
            var filenames = this._index.filenames;
            var docnames = this._index.docnames;
            var objects = this._index.objects;
            var objnames = this._index.objnames;
        Severity: Major
        Found in docs/build/_static/searchtools.js - About 2 hrs to fix

          Function remove has 52 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              remove: function( elem, types, handler, selector, mappedTypes ) {
          
                  var j, origCount, tmp,
                      events, t, handleObj,
                      special, handlers, type, namespaces, origType,
          Severity: Major
          Found in docs/build/_static/jquery-3.5.1.js - About 2 hrs to fix

            File outputs.py has 252 lines of code (exceeds 250 allowed). Consider refactoring.
            Open

            #! /usr/bin/env python3
            
            """
            A module for plotting and summarising segments information, 
            density-of-states information and effective mass analysis.
            Severity: Minor
            Found in effmass/outputs.py - About 2 hrs to fix

              Function buildFragment has 51 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              function buildFragment( elems, context, scripts, selection, ignored ) {
                  var elem, tmp, tag, wrap, attached, j,
                      fragment = context.createDocumentFragment(),
                      nodes = [],
                      i = 0,
              Severity: Major
              Found in docs/build/_static/jquery-3.5.1.js - About 2 hrs to fix

                Consider simplifying this complex logical expression.
                Open

                                if ( ( mappedTypes || origType === handleObj.origType ) &&
                                    ( !handler || handler.guid === handleObj.guid ) &&
                                    ( !tmp || tmp.test( handleObj.namespace ) ) &&
                                    ( !selector || selector === handleObj.selector ||
                                        selector === "**" && handleObj.selector ) ) {
                Severity: Critical
                Found in docs/build/_static/jquery-3.5.1.js - About 2 hrs to fix

                  Function select has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                  select = Sizzle.select = function( selector, context, results, seed ) {
                      var i, tokens, token, type, find,
                          compiled = typeof selector === "function" && selector,
                          match = !seed && tokenize( ( selector = compiled.selector || selector ) );
                  
                  
                  Severity: Minor
                  Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                    Function matcherFromTokens has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    function matcherFromTokens( tokens ) {
                        var checkContext, matcher, j,
                            len = tokens.length,
                            leadingRelative = Expr.relative[ tokens[ 0 ].type ],
                            implicitRelative = leadingRelative || Expr.relative[ " " ],
                    Severity: Minor
                    Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                      Function highlightText has 48 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      jQuery.fn.highlightText = function(text, className) {
                        function highlight(node, addItems) {
                          if (node.nodeType === 3) {
                            var val = node.nodeValue;
                            var pos = val.toLowerCase().indexOf(text);
                      Severity: Minor
                      Found in docs/build/_static/doctools.js - About 1 hr to fix

                        Function addCombinator has 47 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        function addCombinator( matcher, combinator, base ) {
                            var dir = combinator.dir,
                                skip = combinator.next,
                                key = skip || dir,
                                checkNonElements = base && key === "parentNode",
                        Severity: Minor
                        Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                          Function tokenize has 46 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                          tokenize = Sizzle.tokenize = function( selector, parseOnly ) {
                              var matched, match, tokens, type,
                                  soFar, groups, preFilters,
                                  cached = tokenCache[ selector + " " ];
                          
                          
                          Severity: Minor
                          Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

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

                                val: function( value ) {
                                    var hooks, ret, valueIsFunction,
                                        elem = this[ 0 ];
                            
                                    if ( !arguments.length ) {
                            Severity: Minor
                            Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                              Function data has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  data: function( key, value ) {
                                      var i, name, data,
                                          elem = this[ 0 ],
                                          attrs = elem && elem.attributes;
                              
                              
                              Severity: Minor
                              Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                                Function leverageNative has 44 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                function leverageNative( el, type, expectSync ) {
                                
                                    // Missing expectSync indicates a trigger call, which must force setup through jQuery.event.add
                                    if ( !expectSync ) {
                                        if ( dataPriv.get( el, type ) === undefined ) {
                                Severity: Minor
                                Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix

                                  Function _mark_minima has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  def _mark_minima(electrons_array):
                                      """Helper function which takes an array of electron energies and returns an
                                      array for masking those which are not minima."""
                                      # create array to append to
                                      not_minima = []
                                  Severity: Minor
                                  Found in effmass/extrema.py - 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 _mark_maxima has a Cognitive Complexity of 14 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  def _mark_maxima(holes_array):
                                      """Helper function which takes an array of hole energies and returns an
                                      array for masking those which are not maxima."""
                                      # create array to append to
                                      not_maxima = []
                                  Severity: Minor
                                  Found in effmass/extrema.py - 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 extend has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  jQuery.extend = jQuery.fn.extend = function() {
                                      var options, name, src, copy, copyIsArray, clone,
                                          target = arguments[ 0 ] || {},
                                          i = 1,
                                          length = arguments.length,
                                  Severity: Minor
                                  Found in docs/build/_static/jquery-3.5.1.js - About 1 hr to fix
                                    Severity
                                    Category
                                    Status
                                    Source
                                    Language