LearnPAd/learnpad

View on GitHub
lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js

Summary

Maintainability
F
1 mo
Test Coverage

File jsonform.js has 3036 lines of code (exceeds 250 allowed). Consider refactoring.
Open

/* Copyright (c) 2012 Joshfire - MIT license */
/**
 * @fileoverview Core of the JSON Form client-side library.
 *
 * Generates an HTML form from a structured data model and a layout description.

    Function buildFromLayout has 230 lines of code (exceeds 25 allowed). Consider refactoring.
    Open

    formTree.prototype.buildFromLayout = function (formElement, context) {
      var schemaElement = null;
      var node = new formNode();
      var view = null;
      var key = null;

      Function computeInitialValues has 179 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      formNode.prototype.computeInitialValues = function (values, ignoreDefaultValues, topDefaultArrayLevel) {
        var self = this;
        var node = null;
        var nbChildren = 1;
        var i = 0;

        Function onInsert has 135 lines of code (exceeds 25 allowed). Consider refactoring.
        Open

            'onInsert': function (evt, node) {
              var $nodeid = $(node.el).find('#' + escapeSelector(node.id));
              var boundaries = node.getArrayBoundaries();
        
              var moveNodeTo = function (fromIdx, toIdx) {

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

          formNode.prototype.getFormValues = function (updateArrayPath) {
            // The values object that will be returned
            var values = {};
          
            if (!this.el) {

            Function initialize has 102 lines of code (exceeds 25 allowed). Consider refactoring.
            Open

            formTree.prototype.initialize = function (formDesc) {
              formDesc = formDesc || {};
            
              // Keep a pointer to the initial JSONForm
              // (note clone returns a shallow copy, only first-level is cloned)

              Function onInsert has 94 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                  'onInsert': function (evt, node) {
                    var $nodeid = $(node.el).find('#' + escapeSelector(node.id));
                    var boundaries = node.getArrayBoundaries();
              
                    // Switch two nodes in an array

                Function getArrayBoundaries has 70 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                formNode.prototype.getArrayBoundaries = function () {
                  var boundaries = {
                    minItems: -1,
                    maxItems: -1
                  };

                  Function onBeforeRender has 68 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                      'onBeforeRender': function (data, node) {
                        // Before rendering, this function ensures that:
                        // 1. direct children have IDs (used to show/hide the tabs contents)
                        // 2. the tab to active is flagged accordingly. The active tab is
                        // the first one, except if form values are available, in which case

                    Function getInitialValue has 66 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    var getInitialValue = function (formObject, key, arrayPath, tpldata, usePreviousValues) {
                      var value = null;
                    
                      // Complete template data for template function
                      tpldata = tpldata || {};

                      Function enhance has 66 lines of code (exceeds 25 allowed). Consider refactoring.
                      Open

                      formNode.prototype.enhance = function () {
                        var node = this;
                        var handlers = null;
                        var handler = null;
                        var formData = _.clone(this.ownerTree.formDesc.tpldata) || {};

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

                        var inputFieldTemplate = function (type, isTextualInput, extraOpts) {
                          var templ = {
                            'template': '<input type="' + type + '" ' +
                              'class="<%= fieldHtmlClass' + (isTextualInput ? ' || cls.textualInputClass' : '') + ' %>" ' +
                              'name="<%= node.name %>" value="<%= escape(value) %>" id="<%= id %>"' +

                          Function getNodeBoundaries has 62 lines of code (exceeds 25 allowed). Consider refactoring.
                          Open

                            var getNodeBoundaries = function (node, initialNode) {
                              var schemaKey = null;
                              var arrayKey = null;
                              var boundaries = {
                                minItems: -1,

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

                            jsonform.util.setObjKey = function(obj,key,value) {
                              var innerobj = obj;
                              var keyparts = key.split(".");
                              var subkey = null;
                              var arrayMatch = null;

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

                              formNode.prototype.generate = function () {
                                var data = {
                                  id: this.id,
                                  keydash: this.keydash,
                                  elt: this.formElement,

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

                                var initializeTabs = function (tabs) {
                                  var activate = function (element, container) {
                                    container
                                      .find('> .active')
                                      .removeClass('active');

                                  Function numberFieldTemplate has 49 lines of code (exceeds 25 allowed). Consider refactoring.
                                  Open

                                  var numberFieldTemplate = function (type, isTextualInput) {
                                    return {
                                      'template': '<input type="' + type + '" ' +
                                        'class="<%= fieldHtmlClass' + (isTextualInput ? ' || cls.textualInputClass' : '') + ' %>" ' +
                                        'name="<%= node.name %>" value="<%= escape(value) %>" id="<%= id %>"' +

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

                                    formTree.prototype.validate = function(noErrorDisplay) {
                                    
                                      var values = jsonform.getFormValue(this.domRoot);
                                      var errors = false;
                                    
                                    

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

                                      $.fn.jsonFormErrors = function(errors, options) {
                                        $("."+jsonform.defaultClasses.groupMarkClassPrefix+"error", this).removeClass(jsonform.defaultClasses.groupMarkClassPrefix+"error");
                                        $("."+jsonform.defaultClasses.groupMarkClassPrefix+"warning", this).removeClass(jsonform.defaultClasses.groupMarkClassPrefix+"warning");
                                      
                                        $(".jsonform-errortext", this).hide();

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

                                            'onInsert': function(evt, node) {
                                              if (node.formElement && node.formElement.autocomplete) {
                                                var $input = $(node.el).find('input');
                                                if ($input.autocomplete) {
                                                  $input.autocomplete(node.formElement.autocomplete);

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

                                          jsonform.fieldTemplate = function(inner) {
                                            return '<div class="<%= cls.groupClass %> jsonform-node jsonform-error-<%= keydash %>' +
                                              '<%= elt.htmlClass ? " " + elt.htmlClass : "" %>' +
                                              '<%= (node.required && node.formElement && (node.formElement.type !== "checkbox") ? " jsonform-required" : "") %>' +
                                              '<%= (node.isReadOnly() ? " jsonform-readonly" : "") %>' +

                                            Consider simplifying this complex logical expression.
                                            Open

                                              if (formElement.key) {
                                                // The form element is directly linked to an element in the JSON
                                                // schema. The properties of the form element override those of the
                                                // element in the JSON schema. Properties from the JSON schema complete
                                                // those of the form element otherwise.

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

                                                  'onInsert': function (evt, node) {
                                                    var setup = function () {
                                                      var formElement = node.formElement || {};
                                                      var ace = window.ace;
                                                      var editor = ace.edit($(node.el).find('#' + escapeSelector(node.id) + '__ace').get(0));

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

                                                    'onBeforeRender': function (data, node) {
                                                      // Build up choices from the enumeration/options list
                                                      if (!node || !node.schemaElement || !node.schemaElement.items) return;
                                                      var choices = node.formElement.options;
                                                      if (!choices) return;

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

                                                        var updateTabs = function (selIdx) {
                                                          var tabs = '';
                                                          var activateFirstTab = false;
                                                          if (selIdx === undefined) {
                                                            selIdx = $('> .tabbable > .nav-tabs .active', $nodeid).data('idx');

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

                                                    $.fn.jsonForm = function(options, param1) {
                                                      if (options === 'values') {
                                                        return jsonform.getFormValue(this);
                                                      }
                                                      if (options === 'submit') {

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

                                                          'onInsert': function (evt, node) {
                                                            var activeClass = 'active';
                                                            var elt = node.formElement || {};
                                                            if (elt.activeClass) {
                                                              activeClass += ' ' + elt.activeClass;

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

                                                        jsonform.util.getObjKey = function (obj, key, ignoreArrays) {
                                                          var innerobj = obj;
                                                          var keyparts = key.split(".");
                                                          var subkey = null;
                                                          var arrayMatch = null;

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

                                                            function convertSchemaV3ToV4(schema) {
                                                              if (schema && schema.properties) {
                                                                var required = Array.isArray(schema.required) ? schema.required : [];
                                                                for (var field in schema.properties) {
                                                                  var fieldSchema = schema.properties[field];

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

                                                                function prepareOptions(formElement, enumValues) {
                                                                  if (formElement.options) {
                                                                    if (Array.isArray(formElement.options)) {
                                                                      formElement.options = formElement.options.map(function(value) {
                                                                        return hasOwnProperty(value, 'value') ? value : {

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

                                                                  'onInsert': function (evt, node) {
                                                                    // FIXME: consider default values?
                                                                    function inputHasAnyValue(inputs) {
                                                                      var anyValue = false;
                                                                      inputs.each(function() {

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

                                                                var getSchemaDefaultByKeyWithArrayIdx = function(schema, key, topDefaultArrayLevel) {
                                                                  topDefaultArrayLevel = topDefaultArrayLevel || 0;
                                                                  var defaultValue = undefined;
                                                                  if (!isSet(key) || key === '') {
                                                                    if (topDefaultArrayLevel == 0)

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

                                                                      'onChange': function (evt, elt) {
                                                                        // The "transloadit" function should be called only once to enable
                                                                        // the service when the form is submitted. Has it already been done?
                                                                        if (elt.ownerTree._transloadit_bound) {
                                                                          return false;

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

                                                                        'onInsert': function (evt, node) {
                                                                          $(node.el).on('click', '.dropdown-menu a', function (evt) {
                                                                            evt.preventDefault();
                                                                            evt.stopPropagation();
                                                                            var img = (evt.target.nodeName.toLowerCase() === 'img') ?

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

                                                                          'onBeforeRender': function (data, node) {
                                                                            data.range = {
                                                                              step: 1
                                                                            };
                                                                            if (type == 'range') {

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

                                                                            'onInsert': function (evt, node) {
                                                                              if (node.formElement.toggleNextMap) {
                                                                                var valueMapToNext = {};
                                                                                for (var value in node.formElement.toggleNextMap) {
                                                                                  var toggleNext = node.formElement.toggleNextMap[value];

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

                                                                              'onChange': function(evt,elt) {
                                                                                // The "transloadit" function should be called only once to enable
                                                                                // the service when the form is submitted. Has it already been done?
                                                                                if (elt.ownerTree._transloadit_bound) {
                                                                                  return false;

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

                                                                                  var setup = function () {
                                                                                    var formElement = node.formElement || {};
                                                                                    var ace = window.ace;
                                                                                    var editor = ace.edit($(node.el).find('#' + escapeSelector(node.id) + '__ace').get(0));
                                                                                    var idSelector = '#' + escapeSelector(node.id) + '__hidden';

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

                                                                                  'childTemplate': function(inner, node) {
                                                                                    // non-inline style, we do not wrap it.
                                                                                    if (!node.formElement.otherField)
                                                                                      return inner;
                                                                                    var template = '';

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

                                                                                formTree.prototype.submit = function(evt) {
                                                                                
                                                                                  var stopEvent = function() {
                                                                                    if (evt) {
                                                                                      evt.preventDefault();

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

                                                                                  formNode.prototype.resetValues = function () {
                                                                                    var params = null;
                                                                                    var idx = 0;
                                                                                  
                                                                                    // Reset value

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

                                                                                    jsonform.util.getObjKeyEx = function (obj, key, objKey) {
                                                                                      var innerobj = obj;
                                                                                    
                                                                                      if (key === null || key === undefined || key === '')
                                                                                        return obj;

                                                                                      Avoid deeply nested control flow statements.
                                                                                      Open

                                                                                            if (schemaDefault && Array.isArray(schemaDefault)) {
                                                                                              nbChildren = schemaDefault.length;
                                                                                            }

                                                                                        Avoid deeply nested control flow statements.
                                                                                        Open

                                                                                                    if (processedSchemaNodes.indexOf(fieldSchema.items) < 0) {
                                                                                                      processedSchemaNodes.push(fieldSchema.items);
                                                                                                      convertSchemaV3ToV4(fieldSchema.items);
                                                                                                    }

                                                                                          Avoid deeply nested control flow statements.
                                                                                          Open

                                                                                                        if (dataset.source && Array.isArray(dataset.source)) {
                                                                                                          var source = dataset.source;
                                                                                                          dataset.source = function(query, cb) {
                                                                                                            var lq = query.toLowerCase();
                                                                                                            cb(source.filter(function(v) {

                                                                                            Avoid deeply nested control flow statements.
                                                                                            Open

                                                                                                    if (isSet(schemaDefault)) {
                                                                                                      this.value = schemaDefault;
                                                                                                      if (_.isString(this.value)) {
                                                                                                        if (this.value.indexOf('{{values.') !== -1) {
                                                                                                          // This label wants to use the value of another input field.

                                                                                              Avoid deeply nested control flow statements.
                                                                                              Open

                                                                                                    if (minItems >= 0) {
                                                                                                      nbChildren = 0;
                                                                                                    }

                                                                                                Avoid deeply nested control flow statements.
                                                                                                Open

                                                                                                          if (!errors) errors = [];

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

                                                                                                  var getInitialValue = function (formObject, key, arrayPath, tpldata, usePreviousValues) {

                                                                                                    Avoid too many return statements within this function.
                                                                                                    Open

                                                                                                        return form.validate(param1);

                                                                                                      Avoid too many return statements within this function.
                                                                                                      Open

                                                                                                        return form;

                                                                                                        Avoid too many return statements within this function.
                                                                                                        Open

                                                                                                          return false;

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

                                                                                                              'onInsert': function (evt, node) {
                                                                                                                $(node.el).find('a._jsonform-delete').on('click', function (evt) {
                                                                                                                  $(node.el).find('._jsonform-preview').remove();
                                                                                                                  $(node.el).find('a._jsonform-delete').remove();
                                                                                                                  $(node.el).find('#' + escapeSelector(node.id)).val('');
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 760..768

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

                                                                                                          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

                                                                                                              'onInsert': function (evt, node) {
                                                                                                                $(node.el).find('a._jsonform-delete').on('click', function (evt) {
                                                                                                                  $(node.el).find('._jsonform-preview').remove();
                                                                                                                  $(node.el).find('a._jsonform-delete').remove();
                                                                                                                  $(node.el).find('#' + escapeSelector(node.id)).val('');
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 686..694

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

                                                                                                          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 (node.options.length > maxColumns) {
                                                                                                                  nbRows = Math.ceil(node.options.length / maxColumns);
                                                                                                                  data.columns = Math.ceil(node.options.length / nbRows);
                                                                                                                }
                                                                                                                else {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 835..841

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

                                                                                                          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 (node.options.length > maxColumns) {
                                                                                                                  nbRows = Math.ceil(node.options.length / maxColumns);
                                                                                                                  data.columns = Math.ceil(node.options.length / nbRows);
                                                                                                                }
                                                                                                                else {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 903..909

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

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (typeof node.schemaElement.maximum !== 'undefined') {
                                                                                                                  if (node.schemaElement.exclusiveMaximum) {
                                                                                                                    data.range.max = node.schemaElement.maximum - step;
                                                                                                                  }
                                                                                                                  else {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 384..391

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 90.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (typeof node.schemaElement.minimum !== 'undefined') {
                                                                                                                  if (node.schemaElement.exclusiveMinimum) {
                                                                                                                    data.range.min = node.schemaElement.minimum + step;
                                                                                                                  }
                                                                                                                  else {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 392..399

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 90.

                                                                                                          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

                                                                                                                while (true) {
                                                                                                                  if (!_.isArray(innerobj[prop])) {
                                                                                                                    innerobj[prop] = [];
                                                                                                                  }
                                                                                                                  innerobj = innerobj[prop];
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1997..2005

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

                                                                                                          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

                                                                                                              while (true) {
                                                                                                                if (!_.isArray(innerobj[prop])) {
                                                                                                                  innerobj[prop] = [];
                                                                                                                }
                                                                                                                innerobj = innerobj[prop];
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1966..1974

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

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  if (fromIdx < toIdx) {
                                                                                                                    if (fromIdx === 0) parentEl.prepend(fromEl);
                                                                                                                    else $(node.children[fromIdx-1].el).after(fromEl);
                                                                                                                    $(node.children[toIdx-1].el).after(toEl);
                                                                                                                  }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1262..1266

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

                                                                                                          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

                                                                                                                  else {
                                                                                                                    if (toIdx === 0) parentEl.prepend(toEl);
                                                                                                                    else $(node.children[toIdx-1].el).after(toEl);
                                                                                                                    $(node.children[fromIdx-1].el).after(fromEl);
                                                                                                                  }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1257..1261

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

                                                                                                          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 (this.parentNode) {
                                                                                                              this.arrayPath = _.clone(this.parentNode.arrayPath);
                                                                                                              if (this.parentNode.view && this.parentNode.view.array) {
                                                                                                                this.arrayPath.push(this.childPos);
                                                                                                              }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 2692..2700

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                            if (this.parentNode) {
                                                                                                              this.arrayPath = _.clone(this.parentNode.arrayPath);
                                                                                                              if (this.parentNode.view && this.parentNode.view.array) {
                                                                                                                this.arrayPath.push(this.childPos);
                                                                                                              }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 2568..2576

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  if (subBoundaries.minItems !== -1) {
                                                                                                                    if (boundaries.minItems !== -1) {
                                                                                                                      boundaries.minItems = Math.max(
                                                                                                                        boundaries.minItems,
                                                                                                                        subBoundaries.minItems
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3548..3558

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  var $next = nextN === 1 ? $(node.el).next() : (nextN === 'all' ? $(node.el).nextAll() : $(node.el).nextAll().slice(0, nextN));
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 956..956

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  if (subBoundaries.maxItems !== -1) {
                                                                                                                    if (boundaries.maxItems !== -1) {
                                                                                                                      boundaries.maxItems = Math.min(
                                                                                                                        boundaries.maxItems,
                                                                                                                        subBoundaries.maxItems
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3537..3547

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                    var $next = nextN === 1 ? $(node.el).next() : (nextN === 'all' ? $(node.el).nextAll() : $(node.el).nextAll().slice(0, nextN));
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 598..598

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 81.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  if (boundaries.maxItems >= 0) {
                                                                                                                    var slotNum = boundaries.maxItems - node.children.length;
                                                                                                                    $nodeid.find('> a._jsonform-array-addmore')
                                                                                                                      .toggleClass('disabled', slotNum <= 1);
                                                                                                                    if (slotNum < 1) {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1270..1277

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

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  if (boundaries.maxItems >= 0) {
                                                                                                                    var slotNum = boundaries.maxItems - node.children.length;
                                                                                                                    $nodeid.find('> span > a._jsonform-array-addmore')
                                                                                                                      .toggleClass('disabled', slotNum <= 1);
                                                                                                                    if (slotNum < 1) {
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1475..1482

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

                                                                                                          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

                                                                                                                    formData.idx = (node.arrayPath.length > 0) ?
                                                                                                                      node.arrayPath[node.arrayPath.length-1] + 1 :
                                                                                                                      node.childPos + 1;
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3364..3366

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 61.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                    formData.idx = (node.arrayPath.length > 0) ?
                                                                                                                      node.arrayPath[node.arrayPath.length-1] + 1 :
                                                                                                                      node.childPos + 1;
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 2928..2930

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 61.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                              'template': '<div>' +
                                                                                                                '<input type="hidden" name="<%= node.name %>" id="<%= node.id %>" value="<%= value %>" />' +
                                                                                                                '<div class="dropdown">' +
                                                                                                                '<a class="<%= node.value ? buttonClass : cls.buttonClass %>" data-toggle="dropdown" href="#"<% if (node.value) { %> style="max-width:<%= width %>px;max-height:<%= height %>px"<% } %>>' +
                                                                                                                  '<% if (node.value) { %><img src="<% if (!node.value.match(/^https?:/)) { %><%= prefix %><% } %><%= node.value %><%= suffix %>" alt="" /><% } else { %><%= buttonTitle %><% } %>' +
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 881..894
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1617..1630

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                              'template': '<div>' +
                                                                                                                '<input type="hidden" name="<%= node.name %>" id="<%= node.id %>" value="<%= value %>" />' +
                                                                                                                '<div class="dropdown">' +
                                                                                                                '<a class="<%= node.value ? buttonClass : cls.buttonClass %>" data-toggle="dropdown" href="#"<% if (node.value) { %> style="max-width:<%= width %>px;max-height:<%= height %>px"<% } %>>' +
                                                                                                                  '<% if (node.value) { %><i class="<%= cls.iconClassPrefix %>-<%= node.value %>" /><% } else { %><%= buttonTitle %><% } %>' +
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 809..822
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1617..1630

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                              'template': '<fieldset class="tab-container <%= elt.htmlClass?elt.htmlClass:"" %>">' +
                                                                                                                '<% if (node.legend) { %><legend><%= node.legend %></legend><% } %>' +
                                                                                                                '<% if (node.formElement.key) { %><input type="hidden" id="<%= node.id %>" name="<%= node.name %>" value="<%= escape(value) %>" /><% } else { %>' +
                                                                                                                  '<a id="<%= node.id %>"></a><% } %>' +
                                                                                                                '<div class="tabbable">' +
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 809..822
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 881..894

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 57.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                  var i = (evt.target.nodeName.toLowerCase() === 'i') ?
                                                                                                                    $(evt.target) :
                                                                                                                    $(evt.target).find('i');
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 850..852

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

                                                                                                          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 img = (evt.target.nodeName.toLowerCase() === 'img') ?
                                                                                                                    $(evt.target) :
                                                                                                                    $(evt.target).find('img');
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 918..920

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

                                                                                                          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

                                                                                                              'template': '<input type="' + type + '" ' +
                                                                                                                'class="<%= fieldHtmlClass' + (isTextualInput ? ' || cls.textualInputClass' : '') + ' %>" ' +
                                                                                                                'name="<%= node.name %>" value="<%= escape(value) %>" id="<%= id %>"' +
                                                                                                                '<%= (node.disabled? " disabled" : "")%>' +
                                                                                                                '<%= (node.isReadOnly() ? " readonly=\'readonly\'" : "") %>' +
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 354..362

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 55.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                              'template': '<input type="' + type + '" ' +
                                                                                                                'class="<%= fieldHtmlClass' + (isTextualInput ? ' || cls.textualInputClass' : '') + ' %>" ' +
                                                                                                                'name="<%= node.name %>" value="<%= escape(value) %>" id="<%= id %>"' +
                                                                                                                '<%= (node.disabled? " disabled" : "")%>' +
                                                                                                                '<%= (node.isReadOnly() ? " readonly=\'readonly\'" : "") %>' +
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 288..296

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 55.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.view.onKeyUp)
                                                                                                                  $(this.el).bind('keyup', function(evt) { node.view.onKeyUp(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3331..3332
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3333..3334
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3338..3339
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3340..3341
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3347..3348

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.formElement.onKeyUp)
                                                                                                                  $(this.el).bind('keyup', function(evt) { node.formElement.onKeyUp(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3331..3332
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3333..3334
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3338..3339
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3340..3341
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3345..3346

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

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.formElement.onChange)
                                                                                                                  $(this.el).bind('change', function(evt) { node.formElement.onChange(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3331..3332
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3338..3339
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3340..3341
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3345..3346
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3347..3348

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.view.onChange)
                                                                                                                  $(this.el).bind('change', function(evt) { node.view.onChange(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3333..3334
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3338..3339
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3340..3341
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3345..3346
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3347..3348

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.view.onClick)
                                                                                                                  $(this.el).bind('click', function(evt) { node.view.onClick(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3331..3332
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3333..3334
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3340..3341
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3345..3346
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3347..3348

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 54.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.formElement.onClick)
                                                                                                                  $(this.el).bind('click', function(evt) { node.formElement.onClick(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3331..3332
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3333..3334
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3338..3339
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3345..3346
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3347..3348

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 54.

                                                                                                          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 nonEmptyKeys = _.filter(_.keys(result.meta), function (key) {
                                                                                                                        return !!isSet(result.meta[key]);
                                                                                                                      });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 737..739

                                                                                                          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

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

                                                                                                                      var nonEmptyKeys = _.filter(_.keys(result.meta), function (key) {
                                                                                                                        return !!isSet(result.meta[key]);
                                                                                                                      });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 663..665

                                                                                                          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

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

                                                                                                                var itv = window.setInterval(function() {
                                                                                                                  if (window.ace) {
                                                                                                                    window.clearInterval(itv);
                                                                                                                    setup();
                                                                                                                  }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 511..516

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                var itv = window.setInterval(function() {
                                                                                                                  if (window.wysihtml5) {
                                                                                                                    window.clearInterval(itv);
                                                                                                                    setup();
                                                                                                                  }
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 577..582

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                $nodeid.find('> span > a._jsonform-array-addmore')
                                                                                                                  .toggleClass('disabled', boundaries.maxItems >= 0 && node.children.length >= boundaries.maxItems);
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1298..1299
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1471..1472
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1547..1548

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

                                                                                                          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

                                                                                                                  $nodeid.find('> a._jsonform-array-addmore')
                                                                                                                    .toggleClass('disabled', boundaries.maxItems >= 0 && node.children.length >= boundaries.maxItems);
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1298..1299
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1322..1323
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1547..1548

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

                                                                                                          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

                                                                                                                $nodeid.find('> a._jsonform-array-addmore')
                                                                                                                  .toggleClass('disabled', boundaries.maxItems >= 0 && node.children.length >= boundaries.maxItems);
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1298..1299
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1322..1323
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1471..1472

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

                                                                                                          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

                                                                                                                  $nodeid.find('> span > a._jsonform-array-addmore')
                                                                                                                    .toggleClass('disabled', boundaries.maxItems >= 0 && node.children.length >= boundaries.maxItems);
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1322..1323
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1471..1472
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 1547..1548

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

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.onClick)
                                                                                                                  $(this.el).bind('click', function(evt) { node.onClick(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3343..3344

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 46.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

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

                                                                                                                if (this.onKeyUp)
                                                                                                                  $(this.el).bind('keyup', function(evt) { node.onKeyUp(evt, node); });
                                                                                                          lp-simulation-environment/simulator/src/main/resources/static/lib/jsonform.js on lines 3336..3337

                                                                                                          Duplicated Code

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

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

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

                                                                                                          Tuning

                                                                                                          This issue has a mass of 46.

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

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

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

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

                                                                                                          Refactorings

                                                                                                          Further Reading

                                                                                                          There are no issues that match your filters.

                                                                                                          Category
                                                                                                          Status