Sign upLogin

phadej/jsstana

View on GitHub
Star

Showing 21 of 33 total issues

Function cli has 92 lines of code (exceeds 25 allowed). Consider refactoring.
Open

function cli(argv) {
  program.parse(argv);
  if (program.stripShebang === undefined) { program.stripShebang = true; }
  if (program.lineNumber === undefined) { program.lineNumber = true; }
  if (program.fileName === undefined) { program.fileName = true; }
Severity: Major
Found in bin/jsgrep.js - About 3 hrs to fix

    Function callMatcher has 59 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function callMatcher(callnew, callee) {
  /* jshint validthis:true */
  callee = callee || "?";

  var calleeMatcher = this.matcher(callee);
    Severity: Major
    Found in lib/matchers/call.js - About 2 hrs to fix

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

      module.exports = jsstana.eslintRule("(var ?name (call require ?param))", function(context, node, m) {
  var n = jsstana.match("(string ?paramname)", m.param);
  if (!n) {
    context.report(m.param, "require argument isn't string");
  }
      Severity: Minor
      Found in eslint-rules/npm-require-name.js - 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 enter has 39 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

                enter: function (node /* , parent */) {
            var match = pattern(node);
            if (match) {
              if (!lines) {
                lines = contents.toString().split(/\n/);
      Severity: Minor
      Found in bin/jsgrep.js - About 1 hr to fix

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

        function matcherString(sexpr) {
  /* jshint validthis:true */
  var that = this;

  if (sexpr.indexOf(".") !== -1) {
        Severity: Minor
        Found in lib/jsstana.js - About 1 hr to fix

          Function colorizeLine has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          function colorizeLine(line, steps) {
  steps = _.sortBy(steps, "pos");

  var prevPos = 0;
  var currVal = 0;
          Severity: Minor
          Found in bin/jsgrep.js - About 1 hr to fix

            Function compileCallMatcher has 27 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function compileCallMatcher(args) {
  /* jshint validthis:true */

  var groups = args.map(function (arg) {
    if (typeof arg === "string" && arg.substr(0, 2) === "??") {
            Severity: Minor
            Found in lib/matchers/call.js - About 1 hr to fix

              Function binaryAssignMatcher has 6 arguments (exceeds 4 allowed). Consider refactoring.
              Open

              function binaryAssignMatcher(ratorName, validOperators, exprType, operator, lhs, rhs) {
              Severity: Minor
              Found in lib/matchers/operator.js - About 45 mins to fix

                Function compileCallMatcher has a Cognitive Complexity of 8 (exceeds 5 allowed). Consider refactoring.
                Open

                function compileCallMatcher(args) {
  /* jshint validthis:true */

  var groups = args.map(function (arg) {
    if (typeof arg === "string" && arg.substr(0, 2) === "??") {
                Severity: Minor
                Found in lib/matchers/call.js - About 45 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 callMatcher has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                function callMatcher(callnew, callee) {
  /* jshint validthis:true */
  callee = callee || "?";

  var calleeMatcher = this.matcher(callee);
                Severity: Minor
                Found in lib/matchers/call.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 matcherString has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                function matcherString(sexpr) {
  /* jshint validthis:true */
  var that = this;

  if (sexpr.indexOf(".") !== -1) {
                Severity: Minor
                Found in lib/jsstana.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 cli has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                function cli(argv) {
  program.parse(argv);
  if (program.stripShebang === undefined) { program.stripShebang = true; }
  if (program.lineNumber === undefined) { program.lineNumber = true; }
  if (program.fileName === undefined) { program.fileName = true; }
                Severity: Minor
                Found in bin/jsgrep.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 literalValue has a Cognitive Complexity of 7 (exceeds 5 allowed). Consider refactoring.
                Open

                function literalValue(type, value) {
  return {
    any: _.identity,
    string: _.identity,
    number: function (v) {
                Severity: Minor
                Found in lib/matchers/literal.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

                Avoid too many return statements within this function.
                Open

                    return function (node) {
      return node.type === "Identifier" && node.name === sexpr ? {} : undefined;
    };
                Severity: Major
                Found in lib/jsstana.js - About 30 mins to fix

                  Avoid too many return statements within this function.
                  Open

                    if (m.name === "jsc" && n.paramname === "jsverify") { return; }
                  Severity: Major
                  Found in eslint-rules/npm-require-name.js - About 30 mins to fix

                    Avoid too many return statements within this function.
                    Open

                      if (m.name === "walk" && n.paramname === "walkdir") { return; }
                    Severity: Major
                    Found in eslint-rules/npm-require-name.js - About 30 mins to fix

                      Avoid too many return statements within this function.
                      Open

                          if (m.name == fileName) { return; }
                      Severity: Major
                      Found in eslint-rules/npm-require-name.js - About 30 mins to fix

                        Avoid too many return statements within this function.
                        Open

                            return literal[sexpr].call(that);
                        Severity: Major
                        Found in lib/jsstana.js - About 30 mins to fix

                          Avoid too many return statements within this function.
                          Open

                              return unknownNodeType.call(that, rator);
                          Severity: Major
                          Found in lib/jsstana.js - About 30 mins to fix

                            Avoid too many return statements within this function.
                            Open

                                return literal.this.call(that);
                            Severity: Major
                            Found in lib/jsstana.js - About 30 mins to fix
                              Severity
                              Category
                              Status
                              Source
                              Language