Sign upLogin

JohnMunsch/PaperQuik

View on GitHub
Star
app/bower_components/paper/dist/paper-core.js

Summary

Maintainability
F
2 yrs
Test Coverage

Function paper has a Cognitive Complexity of 4118 (exceeds 5 allowed). Consider refactoring.
Open

var paper = new function(undefined) {

var Base = new function() {
    var hidden = /^(statics|enumerable|beans|preserve)$/,
Severity: Minor
Found in app/bower_components/paper/dist/paper-core.js - About 3 mos 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 paper has 11307 lines of code (exceeds 25 allowed). Consider refactoring.
Open

var paper = new function(undefined) {

var Base = new function() {
    var hidden = /^(statics|enumerable|beans|preserve)$/,
Severity: Major
Found in app/bower_components/paper/dist/paper-core.js - About 2 mos to fix

    File paper-core.js has 11309 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    /*!
 * Paper.js v0.9.20 - The Swiss Army Knife of Vector Graphics Scripting.
 * http://paperjs.org/
 *
 * Copyright (c) 2011 - 2014, Juerg Lehni & Jonathan Puckey
    Severity: Major
    Found in app/bower_components/paper/dist/paper-core.js - About 1 mo to fix

      Function Color has 450 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      var Color = Base.extend(new function() {
    var types = {
        gray: ['gray'],
        rgb: ['red', 'green', 'blue'],
        hsb: ['hue', 'saturation', 'brightness'],
      Severity: Major
      Found in app/bower_components/paper/dist/paper-core.js - About 2 days to fix

        Function BlendMode has 219 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

        var BlendMode = new function() {
    var min = Math.min,
        max = Math.max,
        abs = Math.abs,
        sr, sg, sb, sa,
        Severity: Major
        Found in app/bower_components/paper/dist/paper-core.js - About 1 day to fix

          Function Base has 173 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          var Base = new function() {
    var hidden = /^(statics|enumerable|beans|preserve)$/,

        forEach = [].forEach || function(iter, bind) {
            for (var i = 0, l = this.length; i < l; i++)
          Severity: Major
          Found in app/bower_components/paper/dist/paper-core.js - About 6 hrs to fix

            Function DomElement has 172 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            var DomElement = new function() {

    var special = /^(checked|value|selected|disabled)$/i,
        translated = { text: 'textContent', html: 'innerHTML' },
        unitless = { lineHeight: 1, zoom: 1, zIndex: 1, opacity: 1 };
            Severity: Major
            Found in app/bower_components/paper/dist/paper-core.js - About 6 hrs to fix

              Function Numerical has 142 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

              var Numerical = new function() {

    var abscissas = [
        [  0.5773502691896257645091488],
        [0,0.7745966692414833770358531],
              Severity: Major
              Found in app/bower_components/paper/dist/paper-core.js - About 5 hrs to fix

                Function statics has 118 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                Path.inject({ statics: new function() {

    var kappa = 0.5522847498307936,
        ellipseSegments = [
            new Segment([-1, 0], [0, kappa ], [0, -kappa]),
                Severity: Major
                Found in app/bower_components/paper/dist/paper-core.js - About 4 hrs to fix

                  Function Color has 116 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                          initialize: function Color(arg) {
            var slice = Array.prototype.slice,
                args = arguments,
                read = 0,
                type,
                  Severity: Major
                  Found in app/bower_components/paper/dist/paper-core.js - About 4 hrs to fix

                    Function arcTo has 115 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                            arcTo: function() {
            var current = getCurrentSegment(this),
                from = current._point,
                to = Point.read(arguments),
                through,
                    Severity: Major
                    Found in app/bower_components/paper/dist/paper-core.js - About 4 hrs to fix

                      Function _hitTestSelf has 113 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                          _hitTestSelf: function(point, options) {
        var that = this,
            style = this.getStyle(),
            segments = this._segments,
            numSegments = segments.length,
                      Severity: Major
                      Found in app/bower_components/paper/dist/paper-core.js - About 4 hrs to fix

                        Function Style has 113 lines of code (exceeds 25 allowed). Consider refactoring.
                        Open

                        var Style = Base.extend(new function() {
    var defaults = {
        fillColor: undefined,
        strokeColor: undefined,
        strokeWidth: 1,
                        Severity: Major
                        Found in app/bower_components/paper/dist/paper-core.js - About 4 hrs to fix

                          Function setPathData has 99 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                              setPathData: function(data) {

        var parts = data.match(/[mlhvcsqtaz][^mlhvcsqtaz]*/ig),
            coords,
            relative = false,
                          Severity: Major
                          Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

                            Function Key has 97 lines of code (exceeds 25 allowed). Consider refactoring.
                            Open

                            var Key = new function() {

    var specialKeys = {
        8: 'backspace',
        9: 'tab',
                            Severity: Major
                            Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

                              Function getIntersections has 88 lines of code (exceeds 25 allowed). Consider refactoring.
                              Open

                                  getIntersections: function(path, _expand) {
        if (this === path)
            path = null;
        if (path && !this.getBounds().touches(path.getBounds()))
            return [];
                              Severity: Major
                              Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

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

                                    function tracePaths(segments, operator, selfOp) {
        operator = operator || function() {
            return true;
        };
        var paths = [],
                                Severity: Major
                                Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

                                  Function computeBoolean has 78 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                      function computeBoolean(path1, path2, operator, subtract) {
        function preparePath(path) {
            return path.clone(false).reduce().reorient().transform(null, true);
        }
                                  Severity: Major
                                  Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

                                    Function draw has 75 lines of code (exceeds 25 allowed). Consider refactoring.
                                    Open

                                        draw: function(ctx, param, parentStrokeMatrix) {
        var updateVersion = this._updateVersion = this._project._updateVersion;
        if (!this._visible || this._opacity === 0)
            return;
        var matrices = param.matrices,
                                    Severity: Major
                                    Found in app/bower_components/paper/dist/paper-core.js - About 3 hrs to fix

                                      Function _getMonoCurves has 74 lines of code (exceeds 25 allowed). Consider refactoring.
                                      Open

                                          _getMonoCurves: function() {
        var monoCurves = this._monoCurves,
            prevCurve;

        function insertCurve(v) {
                                      Severity: Major
                                      Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                            function addCurveIntersections(v1, v2, curve1, curve2, locations, include,
            tMin, tMax, uMin, uMax, oldTDiff, reverse, recursion) {
        if (recursion > 20)
            return;
        var q0x = v2[0], q0y = v2[1], q3x = v2[6], q3y = v2[7],
                                        Severity: Major
                                        Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

                                          Function _draw has 71 lines of code (exceeds 25 allowed). Consider refactoring.
                                          Open

                                              _draw: function(ctx, param, strokeMatrix) {
        var style = this._style,
            hasFill = style.hasFill(),
            hasStroke = style.hasStroke(),
            dontPaint = param.dontFinish || param.clip,
                                          Severity: Major
                                          Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

                                            Function smooth has 67 lines of code (exceeds 25 allowed). Consider refactoring.
                                            Open

                                                    smooth: function() {
            var segments = this._segments,
                size = segments.length,
                closed = this._closed,
                n = size,
                                            Severity: Major
                                            Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                  initialize: function View(project, element) {
        this._project = project;
        this._scope = project._scope;
        this._element = element;
        var size;
                                              Severity: Major
                                              Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                    function getWinding(point, curves, horizontal, testContains) {
        var TOLERANCE = 0.00001,
            x = point.x,
            y = point.y,
            windLeft = 0,
                                                Severity: Major
                                                Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

                                                  Function importSVG has 63 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                      function importSVG(source, options, isRoot) {
        if (!source)
            return null;
        if (!options) {
            options = {};
                                                  Severity: Major
                                                  Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                            _handleEvent: function(type, point, event) {
            if (!this._eventCounters[type])
                return;
            var project = this._project,
                hit = project.hitTest(point, {
                                                    Severity: Major
                                                    Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

                                                      Function toShape has 57 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                          toShape: function(insert) {
        if (!this._closed)
            return null;

        var segments = this._segments,
                                                      Severity: Major
                                                      Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                            initialize: function Rectangle(arg0, arg1, arg2, arg3) {
        var type = typeof arg0,
            read = 0;
        if (type === 'number') {
            this.x = arg0;
                                                        Severity: Major
                                                        Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

                                                          Function _hitTest has 55 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                              _hitTest: function(point, options) {
        if (this._locked || !this._visible || this._guide && !options.guides
                || this.isEmpty())
            return null;
                                                          Severity: Major
                                                          Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                _events: new function() {

        var mouseFlags = {
            mousedown: {
                mousedown: 1,
                                                            Severity: Major
                                                            Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                  function drawSegments(ctx, path, matrix) {
        var segments = path._segments,
            length = segments.length,
            coords = new Array(6),
            first = true,
                                                              Severity: Major
                                                              Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                        _draw: function(ctx, param, strokeMatrix) {
            var dontStart = param.dontStart,
                dontPaint = param.dontFinish || param.clip,
                style = this.getStyle(),
                hasFill = style.hasFill(),
                                                                Severity: Major
                                                                Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                          serialize: function(obj, options, compact, dictionary) {
            options = options || {};

            var root = !dictionary,
                res;
                                                                  Severity: Major
                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                        generateBezier: function(first, last, uPrime, tan1, tan2) {
        var epsilon = 1e-11,
            pt1 = this.points[first],
            pt2 = this.points[last],
            C = [[0, 0], [0, 0]],
                                                                    Severity: Minor
                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 2 hrs to fix

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

                                                                          getAverageColor: function(object) {
        var bounds, path;
        if (!object) {
            bounds = this.getBounds();
        } else if (object instanceof PathItem) {
                                                                      Severity: Minor
                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                            function exportGradient(color) {
        var gradientNode = getDefinition(color, 'color');
        if (!gradientNode) {
            var gradient = color.getGradient(),
                radial = gradient._radial,
                                                                        Severity: Minor
                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                              _transformCoordinates: function(matrix, coords, change) {
        var point = this._point,
            handleIn = !change || !this._handleIn.isZero()
                    ? this._handleIn : null,
            handleOut = !change || !this._handleOut.isZero()
                                                                          Severity: Minor
                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                _setStyles: function(ctx) {
        var style = this._style,
            fillColor = style.getFillColor(),
            strokeColor = style.getStrokeColor(),
            shadowColor = style.getShadowColor();
                                                                            Severity: Minor
                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                  getPathData: function(_matrix, _precision) {
        var segments = this._segments,
            length = segments.length,
            f = new Formatter(_precision),
            coords = new Array(6),
                                                                              Severity: Minor
                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                    getStrokeBounds: function(segments, closed, style, matrix) {
        if (!style.hasStroke())
            return Path.getBounds(segments, closed, style, matrix);
        var length = segments.length - (closed ? 0 : 1),
            radius = style.getStrokeWidth() / 2,
                                                                                Severity: Minor
                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                      function inject(dest, src, enumerable, beans, preserve) {
        var beansNames = {};

        function field(name, val) {
            val = val || (val = describe(src, name))
                                                                                  Severity: Minor
                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                    DomEvent.requestAnimationFrame = new function() {
    var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
        requested = false,
        callbacks = [],
        focused = true,
                                                                                    Severity: Minor
                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                          evaluate: function(v, t, type) {
        var p1x = v[0], p1y = v[1],
            c1x = v[2], c1y = v[3],
            c2x = v[4], c2y = v[5],
            p2x = v[6], p2y = v[7],
                                                                                      Severity: Minor
                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                            function splitPath(intersections) {
        var TOLERANCE = 0.00001,
            linearSegments;

        function resetLinear() {
                                                                                        Severity: Minor
                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                          statics: new function() {
    function createShape(type, point, size, radius, args) {
        var item = new Shape(Base.getNamed(args));
        item._type = type;
        item._size = size;
                                                                                          Severity: Minor
                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                transform: function(matrix, _applyMatrix) {
        if (matrix && matrix.isIdentity())
            matrix = null;
        var _matrix = this._matrix,
            applyMatrix = (_applyMatrix || this._applyMatrix)
                                                                                            Severity: Minor
                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                              Function addCurveIntersections has 13 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                              Open

                                                                                                  function addCurveIntersections(v1, v2, curve1, curve2, locations, include,
            tMin, tMax, uMin, uMax, oldTDiff, reverse, recursion) {
                                                                                              Severity: Major
                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                    _handleEvent: function(type, point, event) {
        paper = this._scope;
        var called = false;
        switch (type) {
        case 'mousedown':
                                                                                                Severity: Minor
                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                  Function matches has 39 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                  Open

                                                                                                      matches: function(match) {
        function matchObject(obj1, obj2) {
            for (var i in obj1) {
                if (obj1.hasOwnProperty(i)) {
                    var val1 = obj1[i],
                                                                                                  Severity: Minor
                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                            function drawSegment(segment) {
            if (matrix) {
                segment._transformCoordinates(matrix, coords, false);
                curX = coords[0];
                curY = coords[1];
                                                                                                    Severity: Minor
                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                          this.process = function(mode, srcContext, dstContext, alpha, offset) {
        var srcCanvas = srcContext.canvas,
            normal = mode === 'normal';
        if (normal || nativeModes[mode]) {
            dstContext.save();
                                                                                                      Severity: Minor
                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                            function clipConvexHull(hullTop, hullBottom, dMin, dMax) {
        var tProxy,
            tVal = null,
            px, py,
            qx, qy;
                                                                                                        Severity: Minor
                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                              _add: function(segs, index) {
        var segments = this._segments,
            curves = this._curves,
            amount = segs.length,
            append = index == null,
                                                                                                          Severity: Minor
                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                            Function applyStyle has 36 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                            Open

                                                                                                                function applyStyle(item, node, isRoot) {
        var attrs = {},
            parent = !isRoot && item.getParent();

        if (item._name != null)
                                                                                                            Severity: Minor
                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                  function fromCSS(string) {
        var match = string.match(/^#(\w{1,2})(\w{1,2})(\w{1,2})$/),
            components;
        if (match) {
            components = [0, 0, 0];
                                                                                                              Severity: Minor
                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                    join: function(path) {
        if (path) {
            var segments = path._segments,
                last1 = this.getLastSegment(),
                last2 = path.getLastSegment();
                                                                                                                Severity: Minor
                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                      function addCurveLineIntersections(v1, v2, curve1, curve2, locations,
            include) {
        var flip = Curve.isLinear(v1),
            vc = flip ? v2 : v1,
            vl = flip ? v1 : v2,
                                                                                                                  Severity: Minor
                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                    Open

                                                                                                                                    if (winding && (winding === 1
                        && y >= values[1] && y <= values[7]
                        || y >= values[7] && y <= values[1])
                    && Curve.solveCubic(values, 1, y, roots, 0,
                        !next.winding && next.values[1] === y ? 1 : MAX) === 1){
                                                                                                                    Severity: Critical
                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                              Rectangle: function() {
            var rect = Rectangle.readNamed(arguments, 'rectangle'),
                radius = Size.readNamed(arguments, 'radius', 0,
                        { readNull: true }),
                bl = rect.getBottomLeft(true),
                                                                                                                      Severity: Minor
                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                            _updateEvent: function(type, point, minDistance, maxDistance, start,
            needsChange, matchMaxDistance) {
        if (!start) {
            if (minDistance != null || maxDistance != null) {
                var minDist = minDistance != null ? minDistance : 0,
                                                                                                                        Severity: Minor
                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                              function exportPath(item, options) {
        if (options.matchShapes) {
            var shape = item.toShape(false);
            if (shape)
                return exportShape(shape, options);
                                                                                                                          Severity: Minor
                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                function drawHandles(ctx, segments, matrix, size) {
        var half = size / 2;

        function drawHandle(index) {
            var hX = coords[index],
                                                                                                                            Severity: Minor
                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                  initialize: function Point(arg0, arg1) {
        var type = typeof arg0;
        if (type === 'number') {
            var hasY = typeof arg1 === 'number';
            this.x = arg0;
                                                                                                                              Severity: Minor
                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                        equals: function(obj1, obj2) {
            function checkKeys(o1, o2) {
                for (var i in o1)
                    if (o1.hasOwnProperty(i) && !o2.hasOwnProperty(i))
                        return false;
                                                                                                                                Severity: Minor
                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                      function applyTransform(item, value, name, node) {
        var transforms = (node.getAttribute(name) || '').split(/\)\s*/g),
            matrix = new Matrix();
        for (var i = 0, l = transforms.length; i < l; i++) {
            var transform = transforms[i];
                                                                                                                                  Severity: Minor
                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                        divide: function(offset, isParameter, ignoreLinear) {
        var parameter = this._getParameter(offset, isParameter),
            tolerance = 0.00001,
            res = null;
        if (parameter > tolerance && parameter < 1 - tolerance) {
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                          split: function(index, parameter) {
        if (parameter === null)
            return;
        if (arguments.length === 1) {
            var arg = index;
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                        Function intersect has 10 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                        Open

                                                                                                                                                intersect: function(apx, apy, avx, avy, bpx, bpy, bvx, bvy, asVector,
                isInfinite) {
                                                                                                                                        Severity: Major
                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                  solveCubic: function(a, b, c, d, roots, min, max) {
            if (abs(a) < EPSILON)
                return Numerical.solveQuadratic(b, c, d, roots, min, max);

            b /= a;
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                _changed: function(flags) {
        var symbol = this._parentSymbol,
            cacheParent = this._parent || symbol,
            project = this._project;
        if (flags & 8) {
                                                                                                                                            Severity: Minor
                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                      function handleCurve(v) {
            if (Curve.getLength(v) === 0)
                return;
            var y0 = v[1],
                y1 = v[3],
                                                                                                                                              Severity: Minor
                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                        toCanvasStyle: function(ctx) {
            if (this._canvasStyle)
                return this._canvasStyle;
            if (this._type !== 'gradient')
                return this._canvasStyle = this.toCSS();
                                                                                                                                                Severity: Minor
                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                      _getCachedBounds: function(getter, matrix, cacheItem, internalGetter) {
        matrix = matrix && matrix.orNullIfIdentity();
        var _matrix = internalGetter ? null : this._matrix.orNullIfIdentity(),
            cache = (!matrix || matrix.equals(_matrix)) && getter;
        var cacheParent = this._parent || this._parentSymbol;
                                                                                                                                                  Severity: Minor
                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                            deserialize: function(json, create, _data) {
            var res = json;
            _data = _data || {};
            if (Array.isArray(json)) {
                var type = json[0],
                                                                                                                                                    Severity: Minor
                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                          function getConvexHull(dq0, dq1, dq2, dq3) {
        var p0 = [ 0, dq0 ],
            p1 = [ 1 / 3, dq1 ],
            p2 = [ 2 / 3, dq2 ],
            p3 = [ 1, dq3 ],
                                                                                                                                                      Severity: Minor
                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                            initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
        var count = arguments.length;
        if (count === 3) {
            this._path = arg0;
            this._segment1 = arg1;
                                                                                                                                                        Severity: Minor
                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                          Function Size has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                          Open

                                                                                                                                                              initialize: function Size(arg0, arg1) {
        var type = typeof arg0;
        if (type === 'number') {
            var hasHeight = typeof arg1 === 'number';
            this.width = arg0;
                                                                                                                                                          Severity: Minor
                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                            Function inject has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                            Open

                                                                                                                                                                    inject: function inject() {
            for (var i = 0, l = arguments.length; i < l; i++) {
                var src = arguments[i],
                    events = src._events;
                if (events) {
                                                                                                                                                            Severity: Minor
                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                              Function fitCubic has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                              Open

                                                                                                                                                                  fitCubic: function(first, last, tan1, tan2) {
        if (last - first == 1) {
            var pt1 = this.points[first],
                pt2 = this.points[last],
                dist = pt1.getDistance(pt2) / 3;
                                                                                                                                                              Severity: Minor
                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                                Function _addBevelJoin has 29 lines of code (exceeds 25 allowed). Consider refactoring.
                                                                                                                                                                Open

                                                                                                                                                                    _addBevelJoin: function(segment, join, radius, miterLimit, addPoint, area) {
        var curve2 = segment.getCurve(),
            curve1 = curve2.getPrevious(),
            point = curve2.getPointAt(0, true),
            normal1 = curve1.getNormalAt(1, true),
                                                                                                                                                                Severity: Minor
                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                      _addBounds: function(v0, v1, v2, v3, coord, padding, min, max, roots) {
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                            read: function(list, start, options, length) {
            if (this === Base) {
                var value = this.peek(list, start);
                list.__index++;
                return value;
                                                                                                                                                                    Severity: Minor
                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                          function getTransform(matrix, coordinates, center) {
        var attrs = new Base(),
            trans = matrix.getTranslation();
        if (coordinates) {
            matrix = matrix.shiftless();
                                                                                                                                                                      Severity: Minor
                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                fields[get] = function(_dontMerge) {
            var owner = this._owner,
                children = owner && owner._children,
                value;
            if (!children || children.length === 0 || _dontMerge
                                                                                                                                                                        Severity: Minor
                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                              removeSegments: function(from, to, _includeCurves) {
        from = from || 0;
        to = Base.pick(to, this._segments.length);
        var segments = this._segments,
            curves = this._curves,
                                                                                                                                                                          Severity: Minor
                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                insertChildren: function(index, items, _preserve, _proto) {
        var children = this._children;
        if (children && items && items.length > 0) {
            items = Array.prototype.slice.apply(items);
            for (var i = items.length - 1; i >= 0; i--) {
                                                                                                                                                                            Severity: Minor
                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                      _hitTestSelf: function _hitTestSelf(point, options) {
            var hit = false;
            if (this.hasStroke()) {
                var type = this._type,
                    radius = this._radius,
                                                                                                                                                                              Severity: Minor
                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                    getBounds: function(segments, closed, style, matrix, strokePadding) {
        var first = segments[0];
        if (!first)
            return new Rectangle();
        var coords = new Array(6),
                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                      function importGroup(node, type, options, isRoot) {
        var nodes = node.childNodes,
            isClip = type === 'clippath',
            item = new Group(),
            project = item._project,
                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                        function importGradient(node, type) {
        var id = (getValue(node, 'href', true) || '').substring(1),
            isRadial = type === 'radialgradient',
            gradient;
        if (id) {
                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                          getNearestLocation: function() {
        var point = Point.read(arguments),
            values = this.getValues(),
            count = 100,
            minDist = Infinity,
                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                                function field(name, val) {
            val = val || (val = describe(src, name))
                    && (val.get ? val : val.value);
            if (typeof val === 'string' && val[0] === '#')
                val = dest[val.substring(1)] || val;
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                          Open

                                                                                                                                                                                                  } else if (segments.length === 8 && isArc(0) && isArc(2) && isArc(4)
                && isArc(6) && isColinear(1, 5) && isColinear(3, 7)) {
            type = Shape.Rectangle;
            size = new Size(getDistance(1, 6), getDistance(0, 3));
            radius = size.subtract(new Size(getDistance(0, 7),
                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                                initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                                  function addLocation(locations, include, curve1, t1, point1, curve2, t2,
            point2) {
                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

                                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                                Open

                                                                                                                                                                                                            if (obj instanceof this
                || options && options.readNull && obj == null && length <= 1) {
                if (readIndex)
                    list.__index = index + 1;
                return obj && options && options.clone ? obj.clone() : obj;
                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 1 hr to fix

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

                                                                                                                                                                                                          getSignedDistance: function(px, py, vx, vy, x, y, asVector) {
                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                        set: function(a, c, b, d, tx, ty, _dontNotify) {
                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                              findRoot: function(f, df, x, a, b, n, tolerance) {
                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                            _updateEvent: function(type, point, minDistance, maxDistance, start,
            needsChange, matchMaxDistance) {
                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                                  getSide: function(px, py, vx, vy, x, y, asVector) {
                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                                    solveCubic: function(a, b, c, d, roots, min, max) {
                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                                  initialize: function CurveLocation(curve, parameter, point, _curve2,
            _parameter2, _point2, _distance) {
                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 50 mins to fix

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

                                                                                                                                                                                                                    function addCurveLineIntersections(v1, v2, curve1, curve2, locations,
            include) {
                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                      solveCubic: function (v, coord, val, roots, min, max) {
                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                        initialize: function Rectangle(x, y, width, height, owner, setter) {
                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                          function addLineIntersection(v1, v2, curve1, curve2, locations, include) {
                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                            _addBevelJoin: function(segment, join, radius, miterLimit, addPoint, area) {
                                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                                  solveQuadratic: function(a, b, c, roots, min, max) {
                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                                getHandleBounds: function(segments, closed, style, matrix, strokePadding,
            joinPadding) {
                                                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                                      getIntersections: function(v1, v2, curve1, curve2, locations, include) {
                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                                    initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
                                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

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

                                                                                                                                                                                                                                      function callEvent(view, type, event, point, target, lastPoint) {
                                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                            if (y0 < yBefore && y0 > yTop) {
                            yTop = y0;
                        } else if (y0 > yAfter && y0 < yBottom) {
                            yBottom = y0;
                        }
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                              if (dir > 0)
                            c1 = c1.getPrevious();
                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                if (k > 0)
                            length -= lengths[k - 1];
                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                  if (testContains && x0 >= xBefore && x0 <= xAfter) {
                            ++windLeft;
                            ++windRight;
                        }
                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                    if (w3 * w4 !== 0) {
                            var curve = w3 < w4 ? c3 : c4,
                                nextCurve = operator(curve._segment1._winding)
                                    ? curve
                                    : w3 < w4 ? c4 : c3,
                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                      if ('setLineDash' in ctx) {
                            ctx.setLineDash(dashArray);
                            ctx.lineDashOffset = dashOffset;
                        } else {
                            ctx.mozDash = dashArray;
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                        if (other && other != set)
                            delete other[item._id];
                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                      if (!compare.test(value))
                        return false;
                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                if (from > 0 || to > 0)
                                flattener.drawPart(ctx,
                                        Math.max(from, 0), Math.max(to, 0));
                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                          if (arg.constructor === Color) {
                        type = arg._type;
                        components = arg._components.slice();
                        alpha = arg._alpha;
                        if (type === 'gradient') {
                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                            if (obj.hasOwnProperty(i))
                        res[i] = Base.serialize(obj[i], options, compact,
                                dictionary);
                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                          } else if (typeof compare === 'function') {
                    if (!compare(value))
                        return false;
                } else if (Base.isPlainObject(compare)) {
                    if (!matchObject(compare, value))
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                    if (sx == -1) tx = ty;
                        else if (sy == -1) ty = tx;
                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                      if (Math.abs(tx - ty) < tolerance)
                            return (tx + ty) * 0.5;
                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                    } else if (x0 <= xBefore) {
                        windLeft += winding;
                    } else if (x0 >= xAfter) {
                        windRight += winding;
                    }
                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                              if (value._owner)
                                value = value.clone();
                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 45 mins to fix

                                                                                                                                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                    if (t < tolerance && c1x === p1x && c1y === p1y
                        || t > 1 - tolerance && c2x === p2x && c2y === p2y) {
                    x = p2x - p1x;
                    y = p2y - p1y;
                } else if (t < tolerance) {
                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                      Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                  if (a === 0 && b === 1
                    && isZero(v[0] - v[2]) && isZero(v[1] - v[3])
                    && isZero(v[6] - v[4]) && isZero(v[7] - v[5])) {
                var dx = v[6] - v[0],
                    dy = v[7] - v[1];
                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                        if (added && (!operator(seg._winding) || selfOp)
                        && (inter = seg._intersection)
                        && (interSeg = inter._segment)
                        && interSeg !== startSeg) {
                    if (selfOp) {
                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                      if ((!point || point === this._point || point === this._handleIn)
                    && (curveIn = curves[index - 1]
                        || path._closed && curves[curves.length - 1]))
                curveIn._changed();
                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                    if (decomp && !decomp.shearing && decomp.rotation % 90 === 0) {
            for (var key in bounds) {
                var rect = bounds[key];
                if (applyMatrix || !rect._internal)
                    matrix._transformBounds(rect, rect);
                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                          } else if (arg0.x !== undefined || arg0.width !== undefined) {
                this.x = arg0.x || 0;
                this.y = arg0.y || 0;
                this.width = arg0.width || 0;
                this.height = arg0.height || 0;
                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                if ((curves[i].winding === 1
                        && y >= values[1] && y <= values[7]
                        || y >= values[7] && y <= values[1])
                        && Curve.solveCubic(values, 1, y, roots, 0, 1) > 0) {
                    for (var j = roots.length - 1; j >= 0; j--)
                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

                                                                                                                                                                                                                                                                                  Consider simplifying this complex logical expression.
                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                  if ((isInfinite || 0 <= ta && ta <= 1)
                        && (isInfinite || 0 <= tb && tb <= 1))
                    return new Point(
                                apx + ta * avx,
                                apy + ta * avy);
                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 40 mins to fix

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

                                                                                                                                                                                                                                                                                        function createShape(type, point, size, radius, args) {
                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                          getBounds: function(segments, closed, style, matrix, strokePadding) {
                                                                                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                            this.process = function(mode, srcContext, dstContext, alpha, offset) {
                                                                                                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                              initialize: function MouseEvent(type, event, point, target, delta) {
                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                set: function(x, y, width, height, _dontNotify) {
                                                                                                                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                  _addSquareCap: function(segment, cap, radius, addPoint, area) {
                                                                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                    generateBezier: function(first, last, uPrime, tan1, tan2) {
                                                                                                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                      initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
                                                                                                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                        _drawSelection: function(ctx, matrix, size, selectedItems, updateVersion) {
                                                                                                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                          function inject(dest, src, enumerable, beans, preserve) {
                                                                                                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                                viewBox: function(item, value, name, node, styles) {
                                                                                                                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

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

                                                                                                                                                                                                                                                                                                                  readNamed: function(list, name, start, options, length) {
                                                                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 35 mins to fix

                                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                                            return true;
                                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                                                                                          return false;
                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                                                                                                        return false;
                                                                                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                                                                                Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                                                                                          return true;
                                                                                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                                                                                  Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                                                                                                    return true;
                                                                                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                                                                                    Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                                                                                                  return add(A + p / A - b);
                                                                                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                                                                                      Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                                                                                                return false;
                                                                                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                                                                                        Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                                                                                              return false;
                                                                                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                                                                                          Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

                                                                                                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                                                                                                                return false;
                                                                                                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                                                                                                            Found in app/bower_components/paper/dist/paper-core.js - About 30 mins to fix

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

                                                                                                                                                                                                                                                                                                                              var Path = PathItem.extend({
    _class: 'Path',
    _serializeFields: {
        segments: [],
        closed: false
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 mos to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 6480..7959

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Item = Base.extend(Callback, {
    statics: {
        extend: function extend(src) {
            if (src._serializeFields)
                src._serializeFields = new Base(
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 mos to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 2622..4038

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Curve = Base.extend({
    _class: 'Curve',
    initialize: function Curve(arg0, arg1, arg2, arg3, arg4, arg5, arg6, arg7) {
        var count = arguments.length;
        if (count === 3) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 mos to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 5273..6113

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Color = Base.extend(new function() {
    var types = {
        gray: ['gray'],
        rgb: ['red', 'green', 'blue'],
        hsb: ['hue', 'saturation', 'brightness'],
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 mo to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9127..9647

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Matrix = Base.extend({
    _class: 'Matrix',

    initialize: function Matrix(arg) {
        var count = arguments.length,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1886..2292

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

                                                                                                                                                                                                                                                                                                                              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 function() {

    function getValue(node, name, isString, allowNull) {
        var namespace = SVGNamespaces[name],
            value = namespace
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 12333..12794

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Rectangle = Base.extend({
    _class: 'Rectangle',
    _readIndex: true,
    beans: true,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1497..1825

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var View = Base.extend(Callback, {
    _class: 'View',

    initialize: function View(project, element) {
        this._project = project;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10315..10742

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

                                                                                                                                                                                                                                                                                                                              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 function() {
    var formatter;

    function setAttributes(node, attrs) {
        for (var key in attrs) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11950..12331

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              PathItem.inject(new function() {
    function computeBoolean(path1, path2, operator, subtract) {
        function preparePath(path) {
            return path.clone(false).reduce().reorient().transform(null, true);
        }
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8278..8593

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Shape = Item.extend({
    _class: 'Shape',
    _applyMatrix: false,
    _canApplyMatrix: false,
    _boundsSelected: true,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4177..4499

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              Base.inject({
    toString: function() {
        return this._id != null
            ?  (this._class || 'Object') + (this._name
                ? " '" + this._name + "'"
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 244..570

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

                                                                                                                                                                                                                                                                                                                              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 BlendMode = new function() {
    var min = Math.min,
        max = Math.max,
        abs = Math.abs,
        sr, sg, sb, sa,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11652..11898

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Raster = Item.extend({
    _class: 'Raster',
    _applyMatrix: false,
    _canApplyMatrix: false,
    _boundsGetter: 'getBounds',
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4501..4824

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Point = Base.extend({
    _class: 'Point',
    _readIndex: true,

    initialize: function Point(arg0, arg1) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1018..1299

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Segment = Base.extend({
    _class: 'Segment',
    beans: true,

    initialize: function Segment(arg0, arg1, arg2, arg3, arg4, arg5) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4914..5200

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PathFitter = Base.extend({
    initialize: function(path, error) {
        this.points = [];
        var segments = path._segments,
            prev;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 wks to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8830..9016

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PathItem = Item.extend({
    _class: 'PathItem',

    initialize: function PathItem() {
    },
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 6262..6478

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Base = new function() {
    var hidden = /^(statics|enumerable|beans|preserve)$/,

        forEach = [].forEach || function(iter, bind) {
            for (var i = 0, l = this.length; i < l; i++)
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 35..229

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var DomElement = new function() {

    var special = /^(checked|value|selected|disabled)$/i,
        translated = { text: 'textContent', html: 'innerHTML' },
        unitless = { lineHeight: 1, zoom: 1, zIndex: 1, opacity: 1 };
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10017..10214

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var CompoundPath = PathItem.extend({
    _class: 'CompoundPath',
    _serializeFields: {
        children: []
    },
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8094..8276

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Style = Base.extend(new function() {
    var defaults = {
        fillColor: undefined,
        strokeColor: undefined,
        strokeWidth: 1,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9826..10015

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Numerical = new function() {

    var abscissas = [
        [  0.5773502691896257645091488],
        [0,0.7745966692414833770358531],
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 861..1016

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var CurveLocation = Base.extend({
    _class: 'CurveLocation',
    beans: true,

    initialize: function CurveLocation(curve, parameter, point, _curve2,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 6115..6260

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var CanvasView = View.extend({
    _class: 'CanvasView',

    initialize: function CanvasView(project, canvas) {
        if (!(canvas instanceof HTMLCanvasElement)) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10744..10916

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Project = PaperScopeItem.extend({
    _class: 'Project',
    _list: 'projects',
    _reference: 'project',
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 2405..2566

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              Path.inject({ statics: new function() {

    var kappa = 0.5522847498307936,
        ellipseSegments = [
            new Segment([-1, 0], [0, kappa ], [0, -kappa]),
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 7961..8092

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Size = Base.extend({
    _class: 'Size',
    _readIndex: true,

    initialize: function Size(arg0, arg1) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1336..1460

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Tool = PaperScopeItem.extend({
    _class: 'Tool',
    _list: 'tools',
    _reference: 'tool',
    _events: [ 'onActivate', 'onDeactivate', 'onEditOptions',
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 wk to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11437..11590

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Callback = {
    attach: function(type, func) {
        if (typeof type !== 'string') {
            Base.each(type, function(value, key) {
                this.attach(key, value);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 572..691

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              Path.inject({
    _getMonoCurves: function() {
        var monoCurves = this._monoCurves,
            prevCurve;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8595..8705

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PathFlattener = Base.extend({
    initialize: function(path, matrix) {
        this.curves = [];
        this.parts = [];
        this.length = 0;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 6 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8735..8828

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Line = Base.extend({
    _class: 'Line',

    initialize: function Line(arg0, arg1, arg2, arg3, arg4) {
        var asVector = false;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 2294..2403

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Gradient = Base.extend({
    _class: 'Gradient',

    initialize: function Gradient(stops, radial) {
        this._id = Gradient._id = (Gradient._id || 0) + 1;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 5 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9667..9759

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PaperScope = Base.extend({
    _class: 'PaperScope',

    initialize: function PaperScope() {
        paper = this;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 693..793

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var ToolEvent = Event.extend({
    _class: 'ToolEvent',
    _item: null,

    initialize: function ToolEvent(tool, type, event) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11338..11435

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Key = new function() {

    var specialKeys = {
        8: 'backspace',
        9: 'tab',
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 4 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10967..11076

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Group = Item.extend({
    _class: 'Group',
    _selectChildren: true,
    _serializeFields: {
        children: []
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4040..4114

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Layer = Group.extend({
    _class: 'Layer',

    initialize: function Layer(arg) {
        var props = Base.isPlainObject(arg)
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4116..4175

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PointText = TextItem.extend({
    _class: 'PointText',

    initialize: function PointText() {
        TextItem.apply(this, arguments);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9066..9125

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var SegmentPoint = Point.extend({
    initialize: function SegmentPoint(point, owner, key) {
        var x, y, selected;
        if (!point) {
            x = y = 0;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 5202..5271

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var LinkedRectangle = Rectangle.extend({
    initialize: function Rectangle(x, y, width, height, owner, setter) {
        this.set(x, y, width, height, true);
        this._owner = owner;
        this._setter = setter;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1827..1884

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var GradientStop = Base.extend({
    _class: 'GradientStop',

    initialize: function GradientStop(arg0, arg1) {
        if (arg0) {
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9761..9824

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var DomEvent = {
    add: function(el, events) {
        for (var type in events) {
            var func = events[type],
                parts = type.split(/[\s,]+/g);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10216..10264

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Symbol = Base.extend({
    _class: 'Symbol',

    initialize: function Symbol(item, dontCenter) {
        this._id = Symbol._id = (Symbol._id || 0) + 1;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 2568..2620

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PlacedSymbol = Item.extend({
    _class: 'PlacedSymbol',
    _applyMatrix: false,
    _canApplyMatrix: false,
    _boundsGetter: { getBounds: 'getStrokeBounds' },
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4826..4881

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var TextItem = Item.extend({
    _class: 'TextItem',
    _boundsSelected: true,
    _applyMatrix: false,
    _canApplyMatrix: false,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9018..9064

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              DomEvent.requestAnimationFrame = new function() {
    var nativeRequest = DomElement.getPrefixed(window, 'requestAnimationFrame'),
        requested = false,
        callbacks = [],
        focused = true,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10266..10313

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var PaperScopeItem = Base.extend(Callback, {

    initialize: function(activate) {
        this._scope = paper;
        this._index = this._scope[this._list].push(this) - 1;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 795..828

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

                                                                                                                                                                                                                                                                                                                              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 SVGStyles = Base.each({
    fillColor: ['fill', 'color'],
    strokeColor: ['stroke', 'color'],
    strokeWidth: ['stroke-width', 'number'],
    strokeCap: ['stroke-linecap', 'string'],
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11900..11943

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              CompoundPath.inject({
    _getMonoCurves: function() {
        var children = this._children,
            monoCurves = [];
        for (var i = 0, l = children.length; i < l; i++)
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 8707..8733

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var CanvasProvider = {
    canvases: [],

    getCanvas: function(width, height) {
        var canvas,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11614..11650

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Formatter = Base.extend({
    initialize: function(precision) {
        this.precision = precision || 5;
        this.multiplier = Math.pow(10, this.precision);
    },
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 830..857

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var LinkedSize = Size.extend({
    initialize: function Size(width, height, owner, setter) {
        this._width = width;
        this._height = height;
        this._owner = owner;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 3 other locations - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-core.js on lines 1301..1334
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1301..1334
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1462..1495

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var LinkedPoint = Point.extend({
    initialize: function Point(x, y, owner, setter) {
        this._x = x;
        this._y = y;
        this._owner = owner;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 3 other locations - About 1 day to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-core.js on lines 1462..1495
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1301..1334
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 1462..1495

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

                                                                                                                                                                                                                                                                                                                              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 Http = {
    request: function(method, url, callback) {
        var xhr = new (window.ActiveXObject || XMLHttpRequest)(
                    'Microsoft.XMLHTTP');
        xhr.open(method.toUpperCase(), url, true);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11592..11612

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              Base.each(Color._types, function(properties, type) {
    var ctor = this[Base.capitalize(type) + 'Color'] = function(arg) {
            var argType = arg != null && typeof arg,
                components = argType === 'object' && arg.length != null
                    ? arg
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 9649..9665

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var HitResult = Base.extend({
    _class: 'HitResult',

    initialize: function HitResult(type, item, values) {
        this.type = type;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 4883..4912

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var MouseEvent = Event.extend({
    _class: 'MouseEvent',

    initialize: function MouseEvent(type, event, point, target, delta) {
        Event.call(this, event);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 11078..11097

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var Event = Base.extend({
    _class: 'Event',

    initialize: function Event(event) {
        this.event = event;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10918..10946

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              var KeyEvent = Event.extend({
    _class: 'KeyEvent',

    initialize: function KeyEvent(down, key, character, event) {
        Event.call(this, event);
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 10948..10965

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

                                                                                                                                                                                                                                                                                                                              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

                                                                                                                                                                                                                                                                                                                              if (typeof define === 'function' && define.amd) {
    define('paper', paper);
} else if (typeof module === 'object' && module
        && typeof module.exports === 'object') {
    module.exports = paper;
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 13139..13144

                                                                                                                                                                                                                                                                                                                              Duplicated Code

                                                                                                                                                                                                                                                                                                                              Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                                                                                              Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                                                                                              When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                                                                                              Tuning

                                                                                                                                                                                                                                                                                                                              This issue has a mass of 72.

                                                                                                                                                                                                                                                                                                                              We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                                                                                              The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                                                                                              If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                                                                                              See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                                                                                              Refactorings

                                                                                                                                                                                                                                                                                                                              Further Reading

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

                                                                                                                                                                                                                                                                                                                              paper = new (PaperScope.inject(Base.exports, {
    enumerable: true,
    Base: Base,
    Numerical: Numerical,
    DomElement: DomElement,
                                                                                                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 13129..13137

                                                                                                                                                                                                                                                                                                                              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

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

                                                                                                                                                                                                                                                                                                                              if (!Array.isArray) {
    Array.isArray = function(obj) {
        return Object.prototype.toString.call(obj) === '[object Array]';
    };
}
                                                                                                                                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                                                                                                                                              Found in app/bower_components/paper/dist/paper-core.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                                                                                              app/bower_components/paper/dist/paper-full.js on lines 234..238

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

                                                                                                                                                                                                                                                                                                                              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