GeoKnow/Jassa-Core

View on GitHub
staging/sparql-parser.js

Summary

Maintainability
F
1 mo
Test Coverage

Function parse has 2317 lines of code (exceeds 25 allowed). Consider refactoring.
Open

  function parse(input) {
    var options = arguments.length > 1 ? arguments[1] : {},

        peg$FAILED = {},

Severity: Major
Found in staging/sparql-parser.js - About 1 wk to fix

    File sparql-parser.js has 2341 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    define([],function(){
     return (function() {
      /*
       * Generated by PEG.js 0.8.0.
       *
    Severity: Major
    Found in staging/sparql-parser.js - About 6 days to fix

      Function peg$parseRule has 198 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

          function peg$parseRule(index) {
            var bc    = peg$bytecode[index],
                ip    = 0,
                ips   = [],
                end   = bc.length,
      Severity: Major
      Found in staging/sparql-parser.js - About 7 hrs to fix

        Function peg$buildException has 61 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            function peg$buildException(message, expected, pos) {
              function cleanupExpected(expected) {
                var i = 1;
        
                expected.sort(function(a, b) {
        Severity: Major
        Found in staging/sparql-parser.js - About 2 hrs to fix

          Function peg$computePosDetails has 27 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

              function peg$computePosDetails(pos) {
                function advance(details, startPos, endPos) {
                  var p, ch;
          
                  for (p = startPos; p < endPos; p++) {
          Severity: Minor
          Found in staging/sparql-parser.js - About 1 hr to fix

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

                  function buildMessage(expected, found) {
                    function stringEscape(s) {
                      function hex(ch) { return ch.charCodeAt(0).toString(16).toUpperCase(); }
            
                      return s
            Severity: Minor
            Found in staging/sparql-parser.js - About 1 hr to fix

              Avoid deeply nested control flow statements.
              Open

                                            if(subj.triplesContext != null) {
                                                var triple = {subject: subj.chainSubject, predicate: pair[0], object: pair[1]}
                                                triplesContext.concat(subj.triplesContext);
                                            } else {
                                                var triple = {subject: subject[j], predicate: pair[0], object: pair[1]}
              Severity: Major
              Found in staging/sparql-parser.js - About 45 mins to fix

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

                  function SyntaxError(message, expected, found, offset, line, column) {
                Severity: Minor
                Found in staging/sparql-parser.js - About 45 mins to fix

                  Avoid deeply nested control flow statements.
                  Open

                                                if(subj.triplesContext != null) {
                                                    var triple = {subject: subj.chainSubject, predicate: pair[0], object: pair[1]}
                                                    triplesContext.concat(subj.triplesContext);
                                                } else {
                                                    var triple = {subject: subject[j], predicate: pair[0], object: pair[1]}
                  Severity: Major
                  Found in staging/sparql-parser.js - About 45 mins to fix

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

                              function(v, ol, rest) {
                                    token = {}
                                    token.token = 'propertylist';
                                    var triplesContext = [];
                                    var pairs = [];
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 2 days to fix
                    staging/sparql-parser.js on lines 939..983

                    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 441.

                    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

                              function(v, ol, rest) {
                                    token = {}
                                    token.token = 'propertylist';
                                    var triplesContext = [];
                                    var pairs = [];
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 2 days to fix
                    staging/sparql-parser.js on lines 1045..1088

                    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 441.

                    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

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

                              function(tn, pairs) {
                                    var triplesContext = tn.triplesContext;
                                    var subject = tn.chainSubject;
                    
                                    if(pairs.pairs) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 2 days to fix
                    staging/sparql-parser.js on lines 903..937

                    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 380.

                    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

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

                              function(tn, pairs) {
                                    var triplesContext = tn.triplesContext;
                                    var subject = tn.chainSubject;
                    
                                    if(pairs.pairs) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 2 days to fix
                    staging/sparql-parser.js on lines 1008..1043

                    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 380.

                    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

                                case 11:
                                  ends.push(end);
                                  ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
                    
                                  if (stack[stack.length - 1] !== peg$FAILED) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 6 hrs to fix
                    staging/sparql-parser.js on lines 2438..2450

                    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 166.

                    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

                                case 10:
                                  ends.push(end);
                                  ips.push(ip + 3 + bc[ip + 1] + bc[ip + 2]);
                    
                                  if (stack[stack.length - 1] === peg$FAILED) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 6 hrs to fix
                    staging/sparql-parser.js on lines 2452..2464

                    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 166.

                    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

                              function(v, vs) {
                                    if(vs.length === 0) {
                                        return v;
                                    }
                    
                    
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 4 hrs to fix
                    staging/sparql-parser.js on lines 1312..1328

                    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 125.

                    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

                              function(v, vs) {
                                    if(vs.length === 0) {
                                        return v;
                                    }
                                    var exp = {};
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 4 hrs to fix
                    staging/sparql-parser.js on lines 1291..1308

                    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 125.

                    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

                              function(b, bs) {
                                   var triples = b.triplesContext;
                                   var toTest = null;
                                    if(bs && typeof(bs) === 'object') {
                                          if(bs.length != null) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 3 hrs to fix
                    staging/sparql-parser.js on lines 735..748

                    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 114.

                    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

                              function(b, bs) {
                                   var triples = b.triplesContext;
                                   var toTest = null;
                                    if(bs && typeof(bs) === 'object') {
                                          if(bs.length != null) {
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 3 hrs to fix
                    staging/sparql-parser.js on lines 653..666

                    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 114.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    for(var i=0; gs && i<gs.length; i++) {
                                        var g = gs[i];
                                        if(g.kind === 'default') {
                                            dataset['default'].push(g.graph);
                                        } else {
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 3 hrs to fix
                    staging/sparql-parser.js on lines 230..237
                    staging/sparql-parser.js on lines 276..283

                    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 99.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    for(var i=0; gs && i<gs.length; i++) {
                                        var g = gs[i];
                                        if(g.kind === 'default') {
                                            dataset['default'].push(g.graph);
                                        } else {
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 3 hrs to fix
                    staging/sparql-parser.js on lines 133..140
                    staging/sparql-parser.js on lines 230..237

                    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 99.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    for(var i=0; gs && i<gs.length; i++) {
                                        var g = gs[i];
                                        if(g.kind === 'default') {
                                            dataset['default'].push(g.graph);
                                        } else {
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 3 hrs to fix
                    staging/sparql-parser.js on lines 133..140
                    staging/sparql-parser.js on lines 276..283

                    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 99.

                    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 5 locations. Consider refactoring.
                    Open

                              function(d, e) {
                                    exp = {};
                                    exp.token = 'expression';
                                    exp.expressionType = 'aggregate';
                                    exp.aggregateType = 'min';
                    Severity: Major
                    Found in staging/sparql-parser.js and 4 other locations - About 2 hrs to fix
                    staging/sparql-parser.js on lines 1706..1716
                    staging/sparql-parser.js on lines 1717..1727
                    staging/sparql-parser.js on lines 1739..1749
                    staging/sparql-parser.js on lines 1754..1764

                    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 84.

                    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 5 locations. Consider refactoring.
                    Open

                              function(d, e) {
                                    exp = {};
                                    exp.token = 'expression';
                                    exp.expressionType = 'aggregate';
                                    exp.aggregateType = 'sum';
                    Severity: Major
                    Found in staging/sparql-parser.js and 4 other locations - About 2 hrs to fix
                    staging/sparql-parser.js on lines 1706..1716
                    staging/sparql-parser.js on lines 1728..1738
                    staging/sparql-parser.js on lines 1739..1749
                    staging/sparql-parser.js on lines 1754..1764

                    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 84.

                    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 5 locations. Consider refactoring.
                    Open

                              function(d, e) {
                                    exp = {};
                                    exp.token = 'expression'
                                    exp.expressionType = 'aggregate'
                                    exp.aggregateType = 'max'
                    Severity: Major
                    Found in staging/sparql-parser.js and 4 other locations - About 2 hrs to fix
                    staging/sparql-parser.js on lines 1706..1716
                    staging/sparql-parser.js on lines 1717..1727
                    staging/sparql-parser.js on lines 1728..1738
                    staging/sparql-parser.js on lines 1754..1764

                    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 84.

                    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 5 locations. Consider refactoring.
                    Open

                              function(d, e) {
                                    exp = {};
                                    exp.token = 'expression'
                                    exp.expressionType = 'aggregate'
                                    exp.aggregateType = 'avg'
                    Severity: Major
                    Found in staging/sparql-parser.js and 4 other locations - About 2 hrs to fix
                    staging/sparql-parser.js on lines 1706..1716
                    staging/sparql-parser.js on lines 1717..1727
                    staging/sparql-parser.js on lines 1728..1738
                    staging/sparql-parser.js on lines 1739..1749

                    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 84.

                    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 5 locations. Consider refactoring.
                    Open

                              function(d, e) {
                                    exp = {};
                                    exp.token = 'expression';
                                    exp.expressionType = 'aggregate';
                                    exp.aggregateType = 'count';
                    Severity: Major
                    Found in staging/sparql-parser.js and 4 other locations - About 2 hrs to fix
                    staging/sparql-parser.js on lines 1717..1727
                    staging/sparql-parser.js on lines 1728..1738
                    staging/sparql-parser.js on lines 1739..1749
                    staging/sparql-parser.js on lines 1754..1764

                    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 84.

                    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

                              function(a, b, c) {
                    
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1891..1898

                    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 72.

                    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

                              function(a, b, c) {
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                                    lit.type = "http://www.w3.org/2001/XMLSchema#double";
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1865..1873

                    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 72.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    if(dataset['named'].length === 0 && dataset['default'].length === 0) {
                                        dataset['default'].push({token:'uri', 
                                                                 prefix:null, 
                                                                 suffix:null, 
                                                                 value:'https://github.com/antoniogarrote/rdfstore-js#default_graph'});
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 143..148
                    staging/sparql-parser.js on lines 240..245

                    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 71.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    if(dataset['named'].length === 0 && dataset['default'].length === 0) {
                                        dataset['default'].push({token:'uri', 
                                                                 prefix:null, 
                                                                 suffix:null, 
                                                                 value:'https://github.com/antoniogarrote/rdfstore-js#default_graph'});
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 143..148
                    staging/sparql-parser.js on lines 286..291

                    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 71.

                    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

                    Identical blocks of code found in 3 locations. Consider refactoring.
                    Open

                                    if(dataset['named'].length === 0 && dataset['default'].length === 0) {
                                        dataset['default'].push({token:'uri', 
                                                                 prefix:null, 
                                                                 suffix:null, 
                                                                 value:'https://github.com/antoniogarrote/rdfstore-js#default_graph'});
                    Severity: Major
                    Found in staging/sparql-parser.js and 2 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 240..245
                    staging/sparql-parser.js on lines 286..291

                    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 71.

                    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

                              function(a, b) {
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                                    lit.type = "http://www.w3.org/2001/XMLSchema#double";
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1874..1881

                    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 70.

                    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

                              function(a, b) {
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                                    lit.type = "http://www.w3.org/2001/XMLSchema#decimal";
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1899..1906

                    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 70.

                    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

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

                              function(i, args) {
                                    var fcall = {};
                                    fcall.token = "expression";
                                    fcall.expressionType = 'irireforfunction';
                                    fcall.iriref = i;
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 819..827

                    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 67.

                    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

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

                              function(i, args) {
                                    var fcall = {};
                                    fcall.token = "expression";
                                    fcall.expressionType = 'irireforfunction'
                                    fcall.iriref = i;
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1766..1774

                    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 67.

                    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

                              function(e1, e2) {
                                    var ex = {};
                                    ex.token = 'expression'
                                    ex.expressionType = 'builtincall'
                                    ex.builtincall = 'langmatches'
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1657..1664

                    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 66.

                    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

                              function(e1, e2) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'sameterm';
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1545..1553

                    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 66.

                    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 11 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression'
                                    ex.expressionType = 'builtincall'
                                    ex.builtincall = 'bound'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(arg) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'isuri';
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(arg) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'isblank';
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'builtincall';
                                    ex.builtincall = 'uri'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression'
                                    ex.expressionType = 'builtincall'
                                    ex.builtincall = 'str'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'builtincall';
                                    ex.builtincall = 'iri'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(ggp) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'notexists';
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(ggp) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'exists';
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression'
                                    ex.expressionType = 'builtincall'
                                    ex.builtincall = 'datatype'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(arg) {
                                  var ex = {};
                                  ex.token = 'expression';
                                  ex.expressionType = 'builtincall';
                                  ex.builtincall = 'isliteral';
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1534..1542
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 11 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression'
                                    ex.expressionType = 'builtincall'
                                    ex.builtincall = 'lang'
                    Severity: Major
                    Found in staging/sparql-parser.js and 10 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1525..1533
                    staging/sparql-parser.js on lines 1554..1562
                    staging/sparql-parser.js on lines 1565..1573
                    staging/sparql-parser.js on lines 1576..1584
                    staging/sparql-parser.js on lines 1587..1595
                    staging/sparql-parser.js on lines 1635..1643
                    staging/sparql-parser.js on lines 1646..1654
                    staging/sparql-parser.js on lines 1665..1673
                    staging/sparql-parser.js on lines 1686..1694
                    staging/sparql-parser.js on lines 1696..1704

                    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 64.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'atomic';
                                    ex.primaryexpression = 'numericliteral';
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'unaryexpression';
                                    ex.unaryexpression = "+";
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'unaryexpression';
                                    ex.unaryexpression = "-";
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'atomic';
                                    ex.primaryexpression = 'rdfliteral';
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'atomic';
                                    ex.primaryexpression = 'var';
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(e) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'unaryexpression';
                                    ex.unaryexpression = "!";
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(v) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'atomic';
                                    ex.primaryexpression = 'booleanliteral';
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1511..1519
                    staging/sparql-parser.js on lines 1613..1621

                    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 62.

                    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 8 locations. Consider refactoring.
                    Open

                              function(args) {
                                    var ex = {};
                                    ex.token = 'expression';
                                    ex.expressionType = 'builtincall';
                                    ex.builtincall = 'coalesce';
                    Severity: Major
                    Found in staging/sparql-parser.js and 7 other locations - About 1 hr to fix
                    staging/sparql-parser.js on lines 1456..1464
                    staging/sparql-parser.js on lines 1465..1473
                    staging/sparql-parser.js on lines 1474..1482
                    staging/sparql-parser.js on lines 1484..1492
                    staging/sparql-parser.js on lines 1493..1501
                    staging/sparql-parser.js on lines 1502..1510
                    staging/sparql-parser.js on lines 1511..1519

                    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 62.

                    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

                              function() {
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                                    lit.type = "http://www.w3.org/2001/XMLSchema#boolean";
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1795..1802

                    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 61.

                    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

                              function() {
                                    lit = {};
                                    lit.token = "literal";
                                    lit.lang = null;
                                    lit.type = "http://www.w3.org/2001/XMLSchema#boolean";
                    Severity: Major
                    Found in staging/sparql-parser.js and 1 other location - About 1 hr to fix
                    staging/sparql-parser.js on lines 1803..1810

                    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 61.

                    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 7 locations. Consider refactoring.
                    Open

                              function(ref) {
                                    var query = {};
                                    query.kind = 'clear';
                                    query.token = 'executableunit'
                                    query.destinyGraph = ref;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1091..1098
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(ref) {
                                    var query = {};
                                    query.kind = 'create';
                                    query.token = 'executableunit'
                                    query.destinyGraph = ref;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1091..1098
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(qs) {
                                    var query = {};
                                    query.kind = 'deletedata';
                                    query.token = 'executableunit'
                                    query.quads = qs;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 1091..1098
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(qs) {
                                    var query = {};
                                    query.kind = 'insertdata';
                                    query.token = 'executableunit'
                                    query.quads = qs;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1091..1098
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(ref) {
                                    var query = {};
                                    query.kind = 'drop';
                                    query.token = 'executableunit'
                                    query.destinyGraph = ref;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1091..1098
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(p) {
                                    var path = {};
                                    path.token = 'path';
                                    path.kind = 'element';
                                    path.value = p;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1160..1167

                    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 51.

                    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 7 locations. Consider refactoring.
                    Open

                              function(elt) {
                                  var path = {};
                                  path.token = 'path';
                                  path.kind = 'inversePath';
                                  path.value = elt;
                    Severity: Major
                    Found in staging/sparql-parser.js and 6 other locations - About 50 mins to fix
                    staging/sparql-parser.js on lines 470..477
                    staging/sparql-parser.js on lines 479..486
                    staging/sparql-parser.js on lines 488..495
                    staging/sparql-parser.js on lines 497..504
                    staging/sparql-parser.js on lines 506..513
                    staging/sparql-parser.js on lines 1091..1098

                    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 51.

                    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

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

                                        for(var j=0; j<currentBasicGraphPatterns.length; j++) {
                                            triplesContext = triplesContext.concat(currentBasicGraphPatterns[j].triplesContext);
                                        }
                    Severity: Minor
                    Found in staging/sparql-parser.js and 1 other location - About 45 mins to fix
                    staging/sparql-parser.js on lines 695..697

                    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 50.

                    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

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

                                                for(var j=0; j<currentBasicGraphPatterns.length; j++) {
                                                    triplesContext = triplesContext.concat(currentBasicGraphPatterns[j].triplesContext);
                                                }
                    Severity: Minor
                    Found in staging/sparql-parser.js and 1 other location - About 45 mins to fix
                    staging/sparql-parser.js on lines 716..718

                    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 50.

                    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

                                    if(sm!=null && (sm.order!=null && sm.order!="")) {
                                        query.order = sm.order;
                                    }
                    Severity: Minor
                    Found in staging/sparql-parser.js and 1 other location - About 45 mins to fix
                    staging/sparql-parser.js on lines 260..262

                    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 50.

                    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

                                    if(sm!=null && (sm.order!=null && sm.order!="")) {
                                        query.order = sm.order;
                                    }
                    Severity: Minor
                    Found in staging/sparql-parser.js and 1 other location - About 45 mins to fix
                    staging/sparql-parser.js on lines 164..166

                    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 50.

                    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

                    There are no issues that match your filters.

                    Category
                    Status