Sign upLogin

darkwallet/darkwallet

View on GitHub
Star
src/vendors/jsqrcode/jsqrcode.js

Summary

Maintainability
F
2 mos
Test Coverage

File jsqrcode.js has 2913 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/*
  Ported to JavaScript by Lazar Laszlo 2011 
  
  lazarsoft@gmail.com, www.lazarsoft.info
Severity: Major
Found in src/vendors/jsqrcode/jsqrcode.js - About 1 wk to fix

    Function FinderPatternFinder has a Cognitive Complexity of 222 (exceeds 5 allowed). Consider refactoring.
    Open

    function FinderPatternFinder()
{
    this.image=null;
    this.possibleCenters = [];
    this.hasSkipped = false;
    Severity: Minor
    Found in src/vendors/jsqrcode/jsqrcode.js - About 4 days to fix

    Cognitive Complexity

    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

    A method's cognitive complexity is based on a few simple rules:

    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
    • Code is considered more complex for each "break in the linear flow of the code"
    • Code is considered more complex when "flow breaking structures are nested"

    Further reading

    Function FinderPatternFinder has 425 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    function FinderPatternFinder()
{
    this.image=null;
    this.possibleCenters = [];
    this.hasSkipped = false;
    Severity: Major
    Found in src/vendors/jsqrcode/jsqrcode.js - About 2 days to fix

      Function AlignmentPatternFinder has a Cognitive Complexity of 100 (exceeds 5 allowed). Consider refactoring.
      Open

      function AlignmentPatternFinder( image,  startX,  startY,  width,  height,  moduleSize,  resultPointCallback)
{
    this.image = image;
    this.possibleCenters = new Array();
    this.startX = startX;
      Severity: Minor
      Found in src/vendors/jsqrcode/jsqrcode.js - About 2 days to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function BitMatrixParser has a Cognitive Complexity of 71 (exceeds 5 allowed). Consider refactoring.
      Open

      function BitMatrixParser(bitMatrix)
{
    var dimension = bitMatrix.Dimension;
    if (dimension < 21 || (dimension & 0x03) != 1)
    {
      Severity: Minor
      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function GF256Poly has a Cognitive Complexity of 68 (exceeds 5 allowed). Consider refactoring.
      Open

      function GF256Poly(field,  coefficients)
{
    if (coefficients == null || coefficients.length == 0)
    {
        throw "System.ArgumentException";
      Severity: Minor
      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function QRCodeDataBlockReader has a Cognitive Complexity of 66 (exceeds 5 allowed). Consider refactoring.
      Open

      function QRCodeDataBlockReader(blocks,  version,  numErrorCorrectionCode)
{
    this.blockPointer = 0;
    this.bitPointer = 7;
    this.dataLength = 0;
      Severity: Minor
      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function Detector has a Cognitive Complexity of 63 (exceeds 5 allowed). Consider refactoring.
      Open

      function Detector(image)
{
    this.image=image;
    this.resultPointCallback = null;
      Severity: Minor
      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

      Cognitive Complexity

      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

      A method's cognitive complexity is based on a few simple rules:

      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
      • Code is considered more complex for each "break in the linear flow of the code"
      • Code is considered more complex when "flow breaking structures are nested"

      Further reading

      Function QRCodeDataBlockReader has 245 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function QRCodeDataBlockReader(blocks,  version,  numErrorCorrectionCode)
{
    this.blockPointer = 0;
    this.bitPointer = 7;
    this.dataLength = 0;
      Severity: Major
      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

        Function Detector has 218 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        function Detector(image)
{
    this.image=image;
    this.resultPointCallback = null;
        Severity: Major
        Found in src/vendors/jsqrcode/jsqrcode.js - About 1 day to fix

          Function ReedSolomonDecoder has a Cognitive Complexity of 51 (exceeds 5 allowed). Consider refactoring.
          Open

          function ReedSolomonDecoder(field)
{
    this.field = field;
    this.decode=function(received,  twoS)
    {
          Severity: Minor
          Found in src/vendors/jsqrcode/jsqrcode.js - About 7 hrs to fix

          Cognitive Complexity

          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

          A method's cognitive complexity is based on a few simple rules:

          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
          • Code is considered more complex for each "break in the linear flow of the code"
          • Code is considered more complex when "flow breaking structures are nested"

          Further reading

          Function GF256Poly has 185 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          function GF256Poly(field,  coefficients)
{
    if (coefficients == null || coefficients.length == 0)
    {
        throw "System.ArgumentException";
          Severity: Major
          Found in src/vendors/jsqrcode/jsqrcode.js - About 7 hrs to fix

            Function AlignmentPatternFinder has 180 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            function AlignmentPatternFinder( image,  startX,  startY,  width,  height,  moduleSize,  resultPointCallback)
{
    this.image = image;
    this.possibleCenters = new Array();
    this.startX = startX;
            Severity: Major
            Found in src/vendors/jsqrcode/jsqrcode.js - About 7 hrs to fix

              Function BitMatrixParser has 143 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              function BitMatrixParser(bitMatrix)
{
    var dimension = bitMatrix.Dimension;
    if (dimension < 21 || (dimension & 0x03) != 1)
    {
              Severity: Major
              Found in src/vendors/jsqrcode/jsqrcode.js - About 5 hrs to fix

                Function ReedSolomonDecoder has 133 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                function ReedSolomonDecoder(field)
{
    this.field = field;
    this.decode=function(received,  twoS)
    {
                Severity: Major
                Found in src/vendors/jsqrcode/jsqrcode.js - About 5 hrs to fix

                  Function findFinderPattern has 108 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      this.findFinderPattern = function(image){
        var tryHarder = false;
        this.image=image;
        var maxI = qrcode.height;
        var maxJ = qrcode.width;
                  Severity: Major
                  Found in src/vendors/jsqrcode/jsqrcode.js - About 4 hrs to fix

                    Function getMiddleBrightnessPerArea has a Cognitive Complexity of 27 (exceeds 5 allowed). Consider refactoring.
                    Open

                    qrcode.getMiddleBrightnessPerArea=function(image)
{
    var numSqrtArea = 4;
    //obtain middle brightness((min + max) / 2) per area
    var areaWidth = Math.floor(qrcode.width / numSqrtArea);
                    Severity: Minor
                    Found in src/vendors/jsqrcode/jsqrcode.js - About 3 hrs to fix

                    Cognitive Complexity

                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                    A method's cognitive complexity is based on a few simple rules:

                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                    • Code is considered more complex for each "break in the linear flow of the code"
                    • Code is considered more complex when "flow breaking structures are nested"

                    Further reading

                    Function BitMatrix has 81 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    function BitMatrix( width,  height)
{
    if(!height)
        height=width;
    if (width < 1 || height < 1)
                    Severity: Major
                    Found in src/vendors/jsqrcode/jsqrcode.js - About 3 hrs to fix

                      Function GF256 has 79 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      function GF256( primitive)
{
    this.expTable = new Array(256);
    this.logTable = new Array(256);
    var x = 1;
                      Severity: Major
                      Found in src/vendors/jsqrcode/jsqrcode.js - About 3 hrs to fix

                        Function checkAndNudgePoints has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
                        Open

                        GridSampler.checkAndNudgePoints=function( image,  points)
        {
            var width = qrcode.width;
            var height = qrcode.height;
            // Check and nudge points from start until we see some that are OK:
                        Severity: Minor
                        Found in src/vendors/jsqrcode/jsqrcode.js - About 3 hrs to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Function process has a Cognitive Complexity of 22 (exceeds 5 allowed). Consider refactoring.
                        Open

                        qrcode.process = function(ctx){
    
    var start = new Date().getTime();

    var image = qrcode.grayScaleToBitmap(qrcode.grayscale());
                        Severity: Minor
                        Found in src/vendors/jsqrcode/jsqrcode.js - About 3 hrs to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Function GF256 has a Cognitive Complexity of 21 (exceeds 5 allowed). Consider refactoring.
                        Open

                        function GF256( primitive)
{
    this.expTable = new Array(256);
    this.logTable = new Array(256);
    var x = 1;
                        Severity: Minor
                        Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                        Cognitive Complexity

                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                        A method's cognitive complexity is based on a few simple rules:

                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                        • Code is considered more complex for each "break in the linear flow of the code"
                        • Code is considered more complex when "flow breaking structures are nested"

                        Further reading

                        Function find has 72 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                            this.find = function()
    {
            var startX = this.startX;
            var height = this.height;
            var maxJ = startX + width;
                        Severity: Major
                        Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                          Function decode has a Cognitive Complexity of 20 (exceeds 5 allowed). Consider refactoring.
                          Open

                          qrcode.decode = function(src){
    
    if(arguments.length==0)
    {
        var canvas_qr = document.getElementById("qr-canvas");
                          Severity: Minor
                          Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                          Cognitive Complexity

                          Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                          A method's cognitive complexity is based on a few simple rules:

                          • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                          • Code is considered more complex for each "break in the linear flow of the code"
                          • Code is considered more complex when "flow breaking structures are nested"

                          Further reading

                          Function crossCheckHorizontal has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              this.crossCheckHorizontal=function( startJ,  centerI,  maxCount, originalStateCountTotal)
        {
            var image = this.image;
            
            var maxJ = qrcode.width;
                          Severity: Major
                          Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                            Function crossCheckVertical has 65 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                                this.crossCheckVertical=function( startI,  centerJ,  maxCount,  originalStateCountTotal)
        {
            var image = this.image;
            
            var maxI = qrcode.height;
                            Severity: Major
                            Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                              Function checkAndNudgePoints has 64 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                              GridSampler.checkAndNudgePoints=function( image,  points)
        {
            var width = qrcode.width;
            var height = qrcode.height;
            // Check and nudge points from start until we see some that are OK:
                              Severity: Major
                              Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                Function Version has 61 lines of code (exceeds 25 allowed). Consider refactoring.
                                Open

                                function Version( versionNumber,  alignmentPatternCenters,  ecBlocks1,  ecBlocks2,  ecBlocks3,  ecBlocks4)
{
    this.versionNumber = versionNumber;
    this.alignmentPatternCenters = alignmentPatternCenters;
    this.ecBlocks = new Array(ecBlocks1, ecBlocks2, ecBlocks3, ecBlocks4);
                                Severity: Major
                                Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                  Function getDataBlocks has a Cognitive Complexity of 18 (exceeds 5 allowed). Consider refactoring.
                                  Open

                                  DataBlock.getDataBlocks=function(rawCodewords,  version,  ecLevel)
{
    
    if (rawCodewords.length != version.TotalCodewords)
    {
                                  Severity: Minor
                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                  Cognitive Complexity

                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                  A method's cognitive complexity is based on a few simple rules:

                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                  • Code is considered more complex for each "break in the linear flow of the code"
                                  • Code is considered more complex when "flow breaking structures are nested"

                                  Further reading

                                  Function getNextBits has 60 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      this.getNextBits = function( numBits)
        {            
            var bits = 0;
            if (numBits < this.bitPointer + 1)
            {
                                  Severity: Major
                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                    Function getDataBlocks has 58 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                    DataBlock.getDataBlocks=function(rawCodewords,  version,  ecLevel)
{
    
    if (rawCodewords.length != version.TotalCodewords)
    {
                                    Severity: Major
                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

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

                                      function BitMatrix( width,  height)
{
    if(!height)
        height=width;
    if (width < 1 || height < 1)
                                      Severity: Minor
                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                      Cognitive Complexity

                                      Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                      A method's cognitive complexity is based on a few simple rules:

                                      • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                      • Code is considered more complex for each "break in the linear flow of the code"
                                      • Code is considered more complex when "flow breaking structures are nested"

                                      Further reading

                                      Function sampleGridx has 18 arguments (exceeds 4 allowed). Consider refactoring.
                                      Open

                                      GridSampler.sampleGridx=function( image,  dimension,  p1ToX,  p1ToY,  p2ToX,  p2ToY,  p3ToX,  p3ToY,  p4ToX,  p4ToY,  p1FromX,  p1FromY,  p2FromX,  p2FromY,  p3FromX,  p3FromY,  p4FromX,  p4FromY)
                                      Severity: Major
                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

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

                                            this.sizeOfBlackWhiteBlackRun=function( fromX,  fromY,  toX,  toY)
        {
            // Mild variant of Bresenham's algorithm;
            // see http://en.wikipedia.org/wiki/Bresenham's_line_algorithm
            var steep = Math.abs(toY - fromY) > Math.abs(toX - fromX);
                                        Severity: Major
                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

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

                                          qrcode.decode = function(src){
    
    if(arguments.length==0)
    {
        var canvas_qr = document.getElementById("qr-canvas");
                                          Severity: Major
                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                            Function sampleGrid3 has a Cognitive Complexity of 16 (exceeds 5 allowed). Consider refactoring.
                                            Open

                                            GridSampler.sampleGrid3=function( image,  dimension,  transform)
        {
            var bits = new BitMatrix(dimension);
            var points = new Array(dimension << 1);
            for (var y = 0; y < dimension; y++)
                                            Severity: Minor
                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                            Cognitive Complexity

                                            Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                            A method's cognitive complexity is based on a few simple rules:

                                            • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                            • Code is considered more complex for each "break in the linear flow of the code"
                                            • Code is considered more complex when "flow breaking structures are nested"

                                            Further reading

                                            Function crossCheckVertical has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                                this.crossCheckVertical=function( startI,  centerJ,  maxCount,  originalStateCountTotal)
        {
            var image = this.image;
            
            var maxI = qrcode.height;
                                            Severity: Minor
                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                              Function quadrilateralToQuadrilateral has 16 arguments (exceeds 4 allowed). Consider refactoring.
                                              Open

                                              PerspectiveTransform.quadrilateralToQuadrilateral=function( x0,  y0,  x1,  y1,  x2,  y2,  x3,  y3,  x0p,  y0p,  x1p,  y1p,  x2p,  y2p,  x3p,  y3p)
                                              Severity: Major
                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

                                                Function PerspectiveTransform has 50 lines of code (exceeds 25 allowed). Consider refactoring.
                                                Open

                                                function PerspectiveTransform( a11,  a21,  a31,  a12,  a22,  a32,  a13,  a23,  a33)
{
    this.a11 = a11;
    this.a12 = a12;
    this.a13 = a13;
                                                Severity: Minor
                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 2 hrs to fix

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

                                                      this.selectBestPatterns=function()
        {
            
            var startSize = this.possibleCenters.length;
            if (startSize < 3)
                                                  Severity: Minor
                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                    Function grayScaleToBitmap has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                                                    Open

                                                    qrcode.grayScaleToBitmap=function(grayScale)
{
    var middle = qrcode.getMiddleBrightnessPerArea(grayScale);
    var sqrtNumArea = middle.length;
    var areaWidth = Math.floor(qrcode.width / sqrtNumArea);
                                                    Severity: Minor
                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                    Cognitive Complexity

                                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                    A method's cognitive complexity is based on a few simple rules:

                                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                    • Code is considered more complex for each "break in the linear flow of the code"
                                                    • Code is considered more complex when "flow breaking structures are nested"

                                                    Further reading

                                                    Function Version has a Cognitive Complexity of 15 (exceeds 5 allowed). Consider refactoring.
                                                    Open

                                                    function Version( versionNumber,  alignmentPatternCenters,  ecBlocks1,  ecBlocks2,  ecBlocks3,  ecBlocks4)
{
    this.versionNumber = versionNumber;
    this.alignmentPatternCenters = alignmentPatternCenters;
    this.ecBlocks = new Array(ecBlocks1, ecBlocks2, ecBlocks3, ecBlocks4);
                                                    Severity: Minor
                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                    Cognitive Complexity

                                                    Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                    A method's cognitive complexity is based on a few simple rules:

                                                    • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                    • Code is considered more complex for each "break in the linear flow of the code"
                                                    • Code is considered more complex when "flow breaking structures are nested"

                                                    Further reading

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

                                                        this.runEuclideanAlgorithm=function( a,  b,  R)
        {
            // Assume a's degree is >= b's
            if (a.Degree < b.Degree)
            {
                                                    Severity: Minor
                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

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

                                                          this.readCodewords=function()
        {
            
            var formatInfo = this.readFormatInformation();
            var version = this.readVersion();
                                                      Severity: Minor
                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                        Function getMiddleBrightnessPerArea has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        qrcode.getMiddleBrightnessPerArea=function(image)
{
    var numSqrtArea = 4;
    //obtain middle brightness((min + max) / 2) per area
    var areaWidth = Math.floor(qrcode.width / numSqrtArea);
                                                        Severity: Minor
                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                          Function orderBestPatterns has 43 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                          qrcode.orderBestPatterns=function(patterns)
        {
            
            function distance( pattern1,  pattern2)
            {
                                                          Severity: Minor
                                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                            Function buildVersions has 40 lines of code (exceeds 25 allowed). Consider refactoring.
                                                            Open

                                                            function buildVersions()
{
    return new Array(new Version(1, new Array(), new ECBlocks(7, new ECB(1, 19)), new ECBlocks(10, new ECB(1, 16)), new ECBlocks(13, new ECB(1, 13)), new ECBlocks(17, new ECB(1, 9))), 
    new Version(2, new Array(6, 18), new ECBlocks(10, new ECB(1, 34)), new ECBlocks(16, new ECB(1, 28)), new ECBlocks(22, new ECB(1, 22)), new ECBlocks(28, new ECB(1, 16))), 
    new Version(3, new Array(6, 22), new ECBlocks(15, new ECB(1, 55)), new ECBlocks(26, new ECB(1, 44)), new ECBlocks(18, new ECB(2, 17)), new ECBlocks(22, new ECB(2, 13))),
                                                            Severity: Minor
                                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

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

                                                                  this.readFormatInformation=function()
    {
            if (this.parsedFormatInfo != null)
            {
                return this.parsedFormatInfo;
                                                              Severity: Minor
                                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

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

                                                                    this.readVersion=function()
        {
            
            if (this.parsedVersion != null)
            {
                                                                Severity: Minor
                                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                  Function processFinderPatternInfo has 37 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                  Open

                                                                      this.processFinderPatternInfo = function( info)
        {
            
            var topLeft = info.TopLeft;
            var topRight = info.TopRight;
                                                                  Severity: Minor
                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                    Function handlePossibleCenter has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                    Open

                                                                        this.handlePossibleCenter=function( stateCount,  i,  j)
        {
            var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
            var centerJ = this.centerFromEnd(stateCount, j); //float
            var centerI = this.crossCheckVertical(i, Math.floor( centerJ), stateCount[2], stateCountTotal); //float
                                                                    Severity: Minor
                                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                      Function onload has 34 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                      Open

                                                                              image.onload=function(){
            //var canvas_qr = document.getElementById("qr-canvas");
            var canvas_qr = document.createElement('canvas');
            var context = canvas_qr.getContext('2d');
            var nheight = image.height;
                                                                      Severity: Minor
                                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                        Function AlignmentPattern has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                        Open

                                                                        function AlignmentPattern(posX, posY,  estimatedModuleSize)
{
    this.x=posX;
    this.y=posY;
    this.count = 1;
                                                                        Severity: Minor
                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                          Function sampleGrid3 has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                          Open

                                                                          GridSampler.sampleGrid3=function( image,  dimension,  transform)
        {
            var bits = new BitMatrix(dimension);
            var points = new Array(dimension << 1);
            for (var y = 0; y < dimension; y++)
                                                                          Severity: Minor
                                                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                            Function decode has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                            Open

                                                                                this.decode=function(received,  twoS)
    {
            var poly = new GF256Poly(this.field, received);
            var syndromeCoefficients = new Array(twoS);
            for(var i=0;i<syndromeCoefficients.length;i++)syndromeCoefficients[i]=0;
                                                                            Severity: Minor
                                                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                              Function FinderPattern has 33 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                              Open

                                                                              function FinderPattern(posX, posY,  estimatedModuleSize)
{
    this.x=posX;
    this.y=posY;
    this.count = 1;
                                                                              Severity: Minor
                                                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

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

                                                                                qrcode.process = function(ctx){
    
    var start = new Date().getTime();

    var image = qrcode.grayScaleToBitmap(qrcode.grayscale());
                                                                                Severity: Minor
                                                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                  Function getFigureString has 30 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                  Open

                                                                                      this.getFigureString=function( dataLength)
        {
            var length = dataLength;
            var intData = 0;
            var strData = "";
                                                                                  Severity: Minor
                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                    Function PerspectiveTransform has 9 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                    Open

                                                                                    function PerspectiveTransform( a11,  a21,  a31,  a12,  a22,  a32,  a13,  a23,  a33)
                                                                                    Severity: Major
                                                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                      Function sizeOfBlackWhiteBlackRunBothWays has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                      Open

                                                                                          this.sizeOfBlackWhiteBlackRunBothWays=function( fromX,  fromY,  toX,  toY)
        {
            
            var result = this.sizeOfBlackWhiteBlackRun(fromX, fromY, toX, toY);
                                                                                      Severity: Minor
                                                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                        Function addOrSubtract has 28 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                        Open

                                                                                            this.addOrSubtract=function( other)
        {
            if (this.field != other.field)
            {
                throw "GF256Polys do not have same GF256 field";
                                                                                        Severity: Minor
                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                          Function ECBlocks has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                          Open

                                                                                          function ECBlocks( ecCodewordsPerBlock,  ecBlocks1,  ecBlocks2)
{
    this.ecCodewordsPerBlock = ecCodewordsPerBlock;
    if(ecBlocks2)
        this.ecBlocks = new Array(ecBlocks1, ecBlocks2);
                                                                                          Severity: Minor
                                                                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                            Function buildFunctionPattern has 26 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                            Open

                                                                                                this.buildFunctionPattern=function()
        {
            var dimension = this.DimensionForVersion;
            var bitMatrix = new BitMatrix(dimension);
                                                                                            Severity: Minor
                                                                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                              Function quadrilateralToSquare has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                              Open

                                                                                              PerspectiveTransform.quadrilateralToSquare=function( x0,  y0,  x1,  y1,  x2,  y2,  x3,  y3)
                                                                                              Severity: Major
                                                                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                                Function squareToQuadrilateral has 8 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                Open

                                                                                                PerspectiveTransform.squareToQuadrilateral=function( x0,  y0,  x1,  y1,  x2,  y2,  x3,  y3)
                                                                                                Severity: Major
                                                                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 1 hr to fix

                                                                                                  Function DataMask110 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask110()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask100 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask100()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask101 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask101()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask000 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask000()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask001 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask001()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask111 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask111()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask010 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask010()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function DataMask011 has a Cognitive Complexity of 9 (exceeds 5 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function DataMask011()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                  Severity: Minor
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 55 mins to fix

                                                                                                  Cognitive Complexity

                                                                                                  Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                  A method's cognitive complexity is based on a few simple rules:

                                                                                                  • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                  • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                  • Code is considered more complex when "flow breaking structures are nested"

                                                                                                  Further reading

                                                                                                  Function AlignmentPatternFinder has 7 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                  function AlignmentPatternFinder( image,  startX,  startY,  width,  height,  moduleSize,  resultPointCallback)
                                                                                                  Severity: Major
                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 50 mins to fix

                                                                                                    Avoid deeply nested control flow statements.
                                                                                                    Open

                                                                                                                                if (bitsRead == 8)
                            {
                                result[resultOffset++] =  currentByte;
                                bitsRead = 0;
                                currentByte = 0;
                                                                                                    Severity: Major
                                                                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                      Avoid deeply nested control flow statements.
                                                                                                      Open

                                                                                                                          if (target < minmax[ax][ay][0])
                        minmax[ax][ay][0] = target;
                                                                                                      Severity: Major
                                                                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

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

                                                                                                        function Version( versionNumber,  alignmentPatternCenters,  ecBlocks1,  ecBlocks2,  ecBlocks3,  ecBlocks4)
                                                                                                        Severity: Minor
                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                          Avoid deeply nested control flow statements.
                                                                                                          Open

                                                                                                                                  if (currentState == 4)
                        {
                            // A winner?
                            if (this.foundPatternCross(stateCount))
                            {
                                                                                                          Severity: Major
                                                                                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                            Avoid deeply nested control flow statements.
                                                                                                            Open

                                                                                                                                        if (this.bitMatrix.get_Renamed(j - col, i))
                            {
                                currentByte |= 1;
                            }
                                                                                                            Severity: Major
                                                                                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                              Avoid deeply nested control flow statements.
                                                                                                              Open

                                                                                                                                  if (target > minmax[ax][ay][1])
                        minmax[ax][ay][1] = target;
                                                                                                              Severity: Major
                                                                                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                Open

                                                                                                                                            if (currentState == 2)
                            {
                                // A winner?
                                if (this.foundPatternCross(stateCount))
                                {
                                                                                                                Severity: Major
                                                                                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 45 mins to fix

                                                                                                                  Function createTransform has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                  Open

                                                                                                                      this.createTransform=function( topLeft,  topRight,  bottomLeft, alignmentPattern, dimension)
                                                                                                                  Severity: Minor
                                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 35 mins to fix

                                                                                                                    Avoid too many return statements within this function.
                                                                                                                    Open

                                                                                                                                    return NaN;
                                                                                                                    Severity: Major
                                                                                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                      Avoid too many return statements within this function.
                                                                                                                      Open

                                                                                                                                  return this.foundPatternCross(stateCount)?this.centerFromEnd(stateCount, i):NaN;
                                                                                                                      Severity: Major
                                                                                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                        Avoid too many return statements within this function.
                                                                                                                        Open

                                                                                                                                        return NaN;
                                                                                                                        Severity: Major
                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                          Avoid too many return statements within this function.
                                                                                                                          Open

                                                                                                                                      return this.foundPatternCross(stateCount)?this.centerFromEnd(stateCount, i):NaN;
                                                                                                                          Severity: Major
                                                                                                                          Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                            Avoid too many return statements within this function.
                                                                                                                            Open

                                                                                                                                            return NaN;
                                                                                                                            Severity: Major
                                                                                                                            Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                              Avoid too many return statements within this function.
                                                                                                                              Open

                                                                                                                                              return NaN;
                                                                                                                              Severity: Major
                                                                                                                              Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                Open

                                                                                                                                            return this.foundPatternCross(stateCount)?this.centerFromEnd(stateCount, j):NaN;
                                                                                                                                Severity: Major
                                                                                                                                Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                  Open

                                                                                                                                                  return NaN;
                                                                                                                                  Severity: Major
                                                                                                                                  Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                    Open

                                                                                                                                                    return NaN;
                                                                                                                                    Severity: Major
                                                                                                                                    Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                      Open

                                                                                                                                                      return NaN;
                                                                                                                                      Severity: Major
                                                                                                                                      Found in src/vendors/jsqrcode/jsqrcode.js - About 30 mins to fix

                                                                                                                                        Function decodeVersionInformation has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                        Version.decodeVersionInformation=function( versionBits)
{
    var bestDifference = 0xffffffff;
    var bestVersion = 0;
    for (var i = 0; i < Version.VERSION_DECODE_INFO.length; i++)
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 25 mins to fix

                                                                                                                                        Cognitive Complexity

                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                        Further reading

                                                                                                                                        Function doDecodeFormatInformation has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                        FormatInformation.doDecodeFormatInformation=function( maskedFormatInfo)
{
    // Find the int in FORMAT_INFO_DECODE_LOOKUP with fewest bits differing
    var bestDifference = 0xffffffff;
    var bestFormatInfo = 0;
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 25 mins to fix

                                                                                                                                        Cognitive Complexity

                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                        Further reading

                                                                                                                                        Function binarize has a Cognitive Complexity of 6 (exceeds 5 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                        qrcode.binarize = function(th){
    var ret = new Array(qrcode.width*qrcode.height);
    for (var y = 0; y < qrcode.height; y++)
    {
        for (var x = 0; x < qrcode.width; x++)
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js - About 25 mins to fix

                                                                                                                                        Cognitive Complexity

                                                                                                                                        Cognitive Complexity is a measure of how difficult a unit of code is to intuitively understand. Unlike Cyclomatic Complexity, which determines how difficult your code will be to test, Cognitive Complexity tells you how difficult your code will be to read and comprehend.

                                                                                                                                        A method's cognitive complexity is based on a few simple rules:

                                                                                                                                        • Code is not considered more complex when it uses shorthand that the language provides for collapsing multiple statements into one
                                                                                                                                        • Code is considered more complex for each "break in the linear flow of the code"
                                                                                                                                        • Code is considered more complex when "flow breaking structures are nested"

                                                                                                                                        Further reading

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

                                                                                                                                                    for (var offset = 0; offset < points.length && nudged; offset += 2)
            {
                var x = Math.floor (points[offset]);
                var y = Math.floor( points[offset + 1]);
                if (x < - 1 || x > width || y < - 1 || y > height)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 day to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 66..95

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

                                                                                                                                        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 offset = points.length - 2; offset >= 0 && nudged; offset -= 2)
            {
                var x = Math.floor( points[offset]);
                var y = Math.floor( points[offset + 1]);
                if (x < - 1 || x > width || y < - 1 || y > height)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 day to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 34..63

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

                                                                                                                                        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 DataMask011()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1451..1470

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

                                                                                                                                        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 DataMask000()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1514..1533

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

                                                                                                                                        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 DataMask010()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1472..1491

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

                                                                                                                                        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 DataMask001()
{
    this.unmaskBitMatrix=function(bits,  dimension)
    {
        for (var i = 0; i < dimension; i++)
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1493..1512

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

                                                                                                                                        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

                                                                                                                                            this.aboutEquals=function( moduleSize,  i,  j)
        {
            if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize)
            {
                var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize);
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2677..2685

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

                                                                                                                                        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

                                                                                                                                            this.aboutEquals=function( moduleSize,  i,  j)
        {
            if (Math.abs(i - this.y) <= moduleSize && Math.abs(j - this.x) <= moduleSize)
            {
                var moduleSizeDiff = Math.abs(moduleSize - this.estimatedModuleSize);
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 4 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3259..3267

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

                                                                                                                                        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 (otherToY < 0)
            {
                scale =  fromY /  (fromY - otherToY);
                otherToY = 0;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 616..625

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

                                                                                                                                        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 (otherToX < 0)
            {
                scale =  fromX /  (fromX - otherToX);
                otherToX = 0;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 629..638

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

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

                                                                                                                                            new Version(35, new Array(6, 30, 54, 78, 102, 126, 150), new ECBlocks(30, new ECB(12, 121), new ECB(7, 122)), new ECBlocks(28, new ECB(12, 47), new ECB(26, 48)), new ECBlocks(30, new ECB(39, 24), new ECB(14, 25)),new ECBlocks(30, new ECB(22, 15), new ECB(41, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 408..408
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 409..409
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 410..410
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 411..411
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 412..412

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

                                                                                                                                            new Version(37, new Array(6, 28, 54, 80, 106, 132, 158), new ECBlocks(30, new ECB(17, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(29, 46), new ECB(14, 47)), new ECBlocks(30, new ECB(49, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(24, 15), new ECB(46, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 407..407
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 408..408
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 410..410
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 411..411
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 412..412

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

                                                                                                                                            new Version(38, new Array(6, 32, 58, 84, 110, 136, 162), new ECBlocks(30, new ECB(4, 122), new ECB(18, 123)), new ECBlocks(28, new ECB(13, 46), new ECB(32, 47)), new ECBlocks(30, new ECB(48, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(42, 15), new ECB(32, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 407..407
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 408..408
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 409..409
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 411..411
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 412..412

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

                                                                                                                                            new Version(39, new Array(6, 26, 54, 82, 110, 138, 166), new ECBlocks(30, new ECB(20, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(40, 47), new ECB(7, 48)), new ECBlocks(30, new ECB(43, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(10, 15), new ECB(67, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 407..407
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 408..408
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 409..409
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 410..410
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 412..412

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

                                                                                                                                            new Version(40, new Array(6, 30, 58, 86, 114, 142, 170), new ECBlocks(30, new ECB(19, 118), new ECB(6, 119)), new ECBlocks(28, new ECB(18, 47), new ECB(31, 48)), new ECBlocks(30, new ECB(34, 24), new ECB(34, 25)), new ECBlocks(30, new ECB(20, 15), new ECB(61, 16))));
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 407..407
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 408..408
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 409..409
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 410..410
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 411..411

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

                                                                                                                                            new Version(36, new Array(6, 24, 50, 76, 102, 128, 154), new ECBlocks(30, new ECB(6, 121), new ECB(14, 122)), new ECBlocks(28, new ECB(6, 47), new ECB(34, 48)), new ECBlocks(30, new ECB(46, 24), new ECB(10, 25)), new ECBlocks(30, new ECB(2, 15), new ECB(64, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 407..407
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 409..409
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 410..410
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 411..411
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 412..412

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

                                                                                                                                            new Version(33, new Array(6, 30, 58, 86, 114, 142), new ECBlocks(30, new ECB(17, 115), new ECB(1, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(21, 47)), new ECBlocks(30, new ECB(29, 24), new ECB(19, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(46, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 400..400
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 401..401
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 402..402
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 403..403
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 406..406

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

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

                                                                                                                                            new Version(34, new Array(6, 34, 62, 90, 118, 146), new ECBlocks(30, new ECB(13, 115), new ECB(6, 116)), new ECBlocks(28, new ECB(14, 46), new ECB(23, 47)), new ECBlocks(30, new ECB(44, 24), new ECB(7, 25)), new ECBlocks(30, new ECB(59, 16), new ECB(1, 17))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 400..400
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 401..401
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 402..402
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 403..403
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 405..405

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

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

                                                                                                                                            new Version(29, new Array(6, 30, 54, 78, 102, 126), new ECBlocks(30, new ECB(7, 116), new ECB(7, 117)), new ECBlocks(28, new ECB(21, 45), new ECB(7, 46)), new ECBlocks(30, new ECB(1, 23), new ECB(37, 24)), new ECBlocks(30, new ECB(19, 15), new ECB(26, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 400..400
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 402..402
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 403..403
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 405..405
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 406..406

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

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

                                                                                                                                            new Version(28, new Array(6, 26, 50, 74, 98, 122), new ECBlocks(30, new ECB(3, 117), new ECB(10, 118)), new ECBlocks(28, new ECB(3, 45), new ECB(23, 46)), new ECBlocks(30, new ECB(4, 24), new ECB(31, 25)), new ECBlocks(30, new ECB(11, 15), new ECB(31, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 401..401
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 402..402
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 403..403
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 405..405
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 406..406

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

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

                                                                                                                                            new Version(30, new Array(6, 26, 52, 78, 104, 130), new ECBlocks(30, new ECB(5, 115), new ECB(10, 116)), new ECBlocks(28, new ECB(19, 47), new ECB(10, 48)), new ECBlocks(30, new ECB(15, 24), new ECB(25, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(25, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 400..400
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 401..401
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 403..403
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 405..405
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 406..406

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

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

                                                                                                                                            new Version(31, new Array(6, 30, 56, 82, 108, 134), new ECBlocks(30, new ECB(13, 115), new ECB(3, 116)), new ECBlocks(28, new ECB(2, 46), new ECB(29, 47)), new ECBlocks(30, new ECB(42, 24), new ECB(1, 25)), new ECBlocks(30, new ECB(23, 15), new ECB(28, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 5 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 400..400
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 401..401
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 402..402
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 405..405
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 406..406

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

                                                                                                                                        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 ECB(count,  dataCodewords)
{
    this.count = count;
    this.dataCodewords = dataCodewords;
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1121..1134

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

                                                                                                                                        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 DataBlock(numDataCodewords,  codewords)
{
    this.numDataCodewords = numDataCodewords;
    this.codewords = codewords;
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 179..192

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

                                                                                                                                        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

                                                                                                                                            new Version(25, new Array(6, 32, 58, 84, 110), new ECBlocks(26, new ECB(8, 106), new ECB(4, 107)), new ECBlocks(28, new ECB(8, 47), new ECB(13, 48)), new ECBlocks(30, new ECB(7, 24), new ECB(22, 25)), new ECBlocks(30, new ECB(22, 15), new ECB(13, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 4 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 395..395
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 396..396
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 398..398
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 399..399

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

                                                                                                                                        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

                                                                                                                                            new Version(23, new Array(6, 30, 54, 74, 102), new ECBlocks(30, new ECB(4, 121), new ECB(5, 122)), new ECBlocks(28, new ECB(4, 47), new ECB(14, 48)), new ECBlocks(30, new ECB(11, 24), new ECB(14, 25)), new ECBlocks(30, new ECB(16, 15), new ECB(14, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 4 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 396..396
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 397..397
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 398..398
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 399..399

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

                                                                                                                                        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

                                                                                                                                            new Version(26, new Array(6, 30, 58, 86, 114), new ECBlocks(28, new ECB(10, 114), new ECB(2, 115)), new ECBlocks(28, new ECB(19, 46), new ECB(4, 47)), new ECBlocks(28, new ECB(28, 22), new ECB(6, 23)), new ECBlocks(30, new ECB(33, 16), new ECB(4, 17))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 4 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 395..395
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 396..396
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 397..397
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 399..399

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

                                                                                                                                        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

                                                                                                                                            new Version(24, new Array(6, 28, 54, 80, 106), new ECBlocks(30, new ECB(6, 117), new ECB(4, 118)), new ECBlocks(28, new ECB(6, 45), new ECB(14, 46)), new ECBlocks(30, new ECB(11, 24), new ECB(16, 25)), new ECBlocks(30, new ECB(30, 16), new ECB(2, 17))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 4 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 395..395
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 397..397
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 398..398
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 399..399

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

                                                                                                                                        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

                                                                                                                                            new Version(27, new Array(6, 34, 62, 90, 118), new ECBlocks(30, new ECB(8, 122), new ECB(4, 123)), new ECBlocks(28, new ECB(22, 45), new ECB(3, 46)), new ECBlocks(30, new ECB(8, 23), new ECB(26, 24)), new ECBlocks(30, new ECB(12, 15),         new ECB(28, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 4 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 395..395
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 396..396
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 397..397
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 398..398

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

                                                                                                                                        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

                                                                                                                                            new Version(16, new Array(6, 26, 50, 74), new ECBlocks(24, new ECB(5, 98), new ECB(1, 99)), new ECBlocks(28, new ECB(7, 45), new ECB(3, 46)), new ECBlocks(24, new ECB(15, 19), new ECB(2, 20)), new ECBlocks(30, new ECB(3, 15), new ECB(13, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(20, new Array(6, 34, 62, 90), new ECBlocks(28, new ECB(3, 107), new ECB(5, 108)), new ECBlocks(26, new ECB(3, 41), new ECB(13, 42)), new ECBlocks(30, new ECB(15, 24), new ECB(5, 25)), new ECBlocks(28, new ECB(15, 15), new ECB(10, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391

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

                                                                                                                                        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

                                                                                                                                            new Version(14, new Array(6, 26, 46, 66), new ECBlocks(30, new ECB(3, 115), new ECB(1, 116)), new ECBlocks(24, new ECB(4, 40), new ECB(5, 41)), new ECBlocks(20, new ECB(11, 16), new ECB(5, 17)), new ECBlocks(24, new ECB(11, 12), new ECB(5, 13))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(17, new Array(6, 30, 54, 78), new ECBlocks(28, new ECB(1, 107), new ECB(5, 108)), new ECBlocks(28, new ECB(10, 46), new ECB(1, 47)), new ECBlocks(28, new ECB(1, 22), new ECB(15, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(17, 15))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(18, new Array(6, 30, 56, 82), new ECBlocks(30, new ECB(5, 120), new ECB(1, 121)), new ECBlocks(26, new ECB(9, 43), new ECB(4, 44)), new ECBlocks(28, new ECB(17, 22), new ECB(1, 23)), new ECBlocks(28, new ECB(2, 14), new ECB(19, 15))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(15, new Array(6, 26, 48, 70), new ECBlocks(22, new ECB(5, 87), new ECB(1, 88)), new ECBlocks(24, new ECB(5, 41), new ECB(5, 42)), new ECBlocks(30, new ECB(5, 24), new ECB(7, 25)), new ECBlocks(24, new ECB(11, 12), new ECB(7, 13))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 391..391
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(19, new Array(6, 30, 58, 86), new ECBlocks(28, new ECB(3, 113), new ECB(4, 114)), new ECBlocks(26, new ECB(3, 44), new ECB(11, 45)), new ECBlocks(26, new ECB(17, 21), new ECB(4, 22)), new ECBlocks(26, new ECB(9, 13), new ECB(16, 14))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 6 other locations - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 386..386
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 387..387
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 388..388
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 389..389
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 390..390
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 392..392

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

                                                                                                                                        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

                                                                                                                                            new Version(12, new Array(6, 32, 58), new ECBlocks(24, new ECB(2, 92), new ECB(2, 93)), new ECBlocks(22, new ECB(6, 36), new ECB(2, 37)), new ECBlocks(26, new ECB(4, 20), new ECB(6, 21)), new ECBlocks(28, new ECB(7, 14), new ECB(4, 15))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 382..382

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

                                                                                                                                        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

                                                                                                                                            new Version(10, new Array(6, 28, 50), new ECBlocks(18, new ECB(2, 68), new ECB(2, 69)), new ECBlocks(26, new ECB(4, 43), new ECB(1, 44)), new ECBlocks(24, new ECB(6, 19), new ECB(2, 20)), new ECBlocks(28, new ECB(6, 15), new ECB(2, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 2 hrs to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 384..384

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

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

                                                                                                                                            new Version(8, new Array(6, 24, 42), new ECBlocks(24, new ECB(2, 97)), new ECBlocks(22, new ECB(2, 38), new ECB(2, 39)), new ECBlocks(22, new ECB(4, 18), new ECB(2, 19)), new ECBlocks(26, new ECB(4, 14), new ECB(2, 15))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 381..381
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 383..383
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 385..385

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

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

                                                                                                                                            new Version(9, new Array(6, 26, 46), new ECBlocks(30, new ECB(2, 116)), new ECBlocks(22, new ECB(3, 36), new ECB(2, 37)), new ECBlocks(20, new ECB(4, 16), new ECB(4, 17)), new ECBlocks(24, new ECB(4, 12), new ECB(4, 13))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 380..380
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 383..383
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 385..385

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

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

                                                                                                                                            new Version(11, new Array(6, 30, 54), new ECBlocks(20, new ECB(4, 81)), new ECBlocks(30, new ECB(1, 50), new ECB(4, 51)), new ECBlocks(28, new ECB(4, 22), new ECB(4, 23)), new ECBlocks(24, new ECB(3, 12), new ECB(8, 13))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 380..380
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 381..381
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 385..385

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

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

                                                                                                                                            new Version(13, new Array(6, 34, 62), new ECBlocks(26, new ECB(4, 107)), new ECBlocks(22, new ECB(8, 37), new ECB(1, 38)), new ECBlocks(24, new ECB(8, 20), new ECB(4, 21)), new ECBlocks(22, new ECB(12, 11), new ECB(4, 12))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 380..380
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 381..381
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 383..383

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

                                                                                                                                        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

                                                                                                                                                    for (var j = 5; j >= 0; j--)
            {
                for (var i = dimension - 9; i >= ijMin; i--)
                {
                    versionBits = this.copyBit(i, j, versionBits);
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1338..1344

                                                                                                                                        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

                                                                                                                                                    for (var i = 5; i >= 0; i--)
            {
                for (var j = dimension - 9; j >= ijMin; j--)
                {
                    versionBits = this.copyBit(i, j, versionBits);
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1322..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 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

                                                                                                                                                    var moduleSizeEst1 = this.sizeOfBlackWhiteBlackRunBothWays(Math.floor( pattern.X), Math.floor( pattern.Y), Math.floor( otherPattern.X), Math.floor(otherPattern.Y));
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 650..650

                                                                                                                                        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

                                                                                                                                                    var moduleSizeEst2 = this.sizeOfBlackWhiteBlackRunBothWays(Math.floor(otherPattern.X), Math.floor(otherPattern.Y), Math.floor( pattern.X), Math.floor(pattern.Y));
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 649..649

                                                                                                                                        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 distance( pattern1,  pattern2)
            {
                xDiff = pattern1.X - pattern2.X;
                yDiff = pattern1.Y - pattern2.Y;
                return  Math.sqrt( (xDiff * xDiff + yDiff * yDiff));
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 671..676

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

                                                                                                                                        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

                                                                                                                                            this.distance=function( pattern1,  pattern2)
    {
        xDiff = pattern1.X - pattern2.X;
        yDiff = pattern1.Y - pattern2.Y;
        return  Math.sqrt( (xDiff * xDiff + yDiff * yDiff));
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2591..2596

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

                                                                                                                                        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

                                                                                                                                            this.set_Renamed=function( x,  y)
        {
            var offset = y * this.rowSize + (x >> 5);
            this.bits[offset] |= 1 << (x & 0x1f);
        }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1058..1062

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

                                                                                                                                            this.flip=function( x,  y)
        {
            var offset = y * this.rowSize + (x >> 5);
            this.bits[offset] ^= 1 << (x & 0x1f);
        }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1053..1057

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

                                                                                                                                                    while (j < maxJ && !image[j+ centerI*qrcode.width] && stateCount[3] < maxCount)
            {
                stateCount[3]++;
                j++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2800..2804
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3344..3348

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

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

                                                                                                                                                    while (i < maxI && !image[centerJ + i*qrcode.width] && stateCount[3] < maxCount)
            {
                stateCount[3]++;
                i++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2875..2879
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3344..3348

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

                                                                                                                                        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

                                                                                                                                                    while (i >= 0 && !image[centerJ + i*qrcode.width] && stateCount[0] <= maxCount)
            {
                stateCount[0]++;
                i--;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2846..2850

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

                                                                                                                                        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

                                                                                                                                                    while (j >= 0 && !image[j+ centerI*qrcode.width] && stateCount[1] <= maxCount)
            {
                stateCount[1]++;
                j--;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3323..3327

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

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

                                                                                                                                                    while (i < maxI && !image[centerJ + i*qrcode.width] && stateCount[2] <= maxCount)
            {
                stateCount[2]++;
                i++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2800..2804
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2875..2879

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

                                                                                                                                        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

                                                                                                                                                    while (i >= 0 && image[centerJ + i*qrcode.width] && stateCount[0] <= maxCount)
            {
                stateCount[0]++;
                i--;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2855..2859

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

                                                                                                                                        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

                                                                                                                                                    while (j >= 0 && image[j+ centerI*qrcode.width] && stateCount[0] <= maxCount)
            {
                stateCount[0]++;
                j--;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2779..2783

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

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

                                                                                                                                                    while (i < maxI && image[centerJ + i*qrcode.width] && stateCount[4] < maxCount)
            {
                stateCount[4]++;
                i++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2884..2888
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3335..3339

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

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

                                                                                                                                                    while (i < maxI && image[centerJ + i*qrcode.width] && stateCount[1] <= maxCount)
            {
                stateCount[1]++;
                i++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2809..2813
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2884..2888

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

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

                                                                                                                                                    while (j < maxJ && image[j+ centerI*qrcode.width] && stateCount[4] < maxCount)
            {
                stateCount[4]++;
                j++;
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 2 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2809..2813
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 3335..3339

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

                                                                                                                                        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

                                                                                                                                                    for (var i = 0; i < size; i++)
            {
                product[i] = this.field.multiply(this.coefficients[i], coefficient);
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1974..1977

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

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

                                                                                                                                            new Version(4, new Array(6, 26), new ECBlocks(20, new ECB(1, 80)), new ECBlocks(18, new ECB(2, 32)), new ECBlocks(26, new ECB(2, 24)), new ECBlocks(16, new ECB(4, 9))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 374..374
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 375..375
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 378..378

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

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

                                                                                                                                            new Version(2, new Array(6, 18), new ECBlocks(10, new ECB(1, 34)), new ECBlocks(16, new ECB(1, 28)), new ECBlocks(22, new ECB(1, 22)), new ECBlocks(28, new ECB(1, 16))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 375..375
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 376..376
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 378..378

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

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

                                                                                                                                            new Version(6, new Array(6, 34), new ECBlocks(18, new ECB(2, 68)), new ECBlocks(16, new ECB(4, 27)), new ECBlocks(24, new ECB(4, 19)), new ECBlocks(28, new ECB(4, 15))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 374..374
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 375..375
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 376..376

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

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

                                                                                                                                            new Version(3, new Array(6, 22), new ECBlocks(15, new ECB(1, 55)), new ECBlocks(26, new ECB(1, 44)), new ECBlocks(18, new ECB(2, 17)), new ECBlocks(22, new ECB(2, 13))),
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 3 other locations - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 374..374
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 376..376
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 378..378

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

                                                                                                                                        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

                                                                                                                                                    for (var i = 0; i < size; i++)
            {
                product[i] = this.field.multiply(this.coefficients[i], scalar);
            }
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 1 hr to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 1993..1996

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

                                                                                                                                        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

                                                                                                                                                    var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 35 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2821..2821

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

                                                                                                                                        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

                                                                                                                                                    var stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] + stateCount[4];
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 35 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2896..2896

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

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

                                                                                                                                                    return new PerspectiveTransform(this.a11 * other.a11 + this.a21 * other.a12 + this.a31 * other.a13, this.a11 * other.a21 + this.a21 * other.a22 + this.a31 * other.a23, this.a11 * other.a31 + this.a21 * other.a32 + this.a31 * other.a33, this.a12 * other.a11 + this.a22 * other.a12 + this.a32 * other.a13, this.a12 * other.a21 + this.a22 * other.a22 + this.a32 * other.a23, this.a12 * other.a31 + this.a22 * other.a32 + this.a32 * other.a33, this.a13 * other.a11 + this.a23 * other.a12 +this.a33 * other.a13, this.a13 * other.a21 + this.a23 * other.a22 + this.a33 * other.a23, this.a13 * other.a31 + this.a23 * other.a32 + this.a33 * other.a33);
                                                                                                                                        Severity: Major
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 8 other locations - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 490..490

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

                                                                                                                                        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

                                                                                                                                                    while (j >= 0 && image[j+ centerI*qrcode.width])
            {
                stateCount[2]++;
                j--;
            }
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2760..2764

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

                                                                                                                                        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

                                                                                                                                                        qrcode.imagedata.data[point+2] = image[x+y*qrcode.width]?255:0;
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2381..2381

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

                                                                                                                                        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

                                                                                                                                                        qrcode.imagedata.data[point+1] = image[x+y*qrcode.width]?0:0;
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2382..2382

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

                                                                                                                                        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

                                                                                                                                                    while (i < maxI && image[centerJ +i*qrcode.width])
            {
                stateCount[2]++;
                i++;
            }
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2866..2870

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

                                                                                                                                        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

                                                                                                                                                    while (i >= 0 && image[centerJ + i*qrcode.width])
            {
                stateCount[2]++;
                i--;
            }
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2837..2841

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

                                                                                                                                        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

                                                                                                                                                    while (j < maxJ && image[j+ centerI*qrcode.width])
            {
                stateCount[2]++;
                j++;
            }
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in src/vendors/jsqrcode/jsqrcode.js and 1 other location - About 30 mins to fix
                                                                                                                                        src/vendors/jsqrcode/jsqrcode.js on lines 2791..2795

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

                                                                                                                                        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