Sign upLogin

vuejs/vue

View on GitHub
Star
packages/weex-vue-framework/factory.js

Summary

Maintainability
F
8 mos
Test Coverage

Function weexFactory has a Cognitive Complexity of 2888 (exceeds 5 allowed). Consider refactoring.
Open

module.exports = function weexFactory (exports, document) {

/*  */

var emptyObject = Object.freeze({});
Severity: Minor
Found in packages/weex-vue-framework/factory.js - About 2 mos to fix

Cognitive Complexity

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

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

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

Further reading

Function weexFactory has 5927 lines of code (exceeds 25 allowed). Consider refactoring.
Open

module.exports = function weexFactory (exports, document) {

/*  */

var emptyObject = Object.freeze({});
Severity: Major
Found in packages/weex-vue-framework/factory.js - About 1 mo to fix

    File factory.js has 5930 lines of code (exceeds 250 allowed). Consider refactoring.
    Open

    'use strict';



module.exports = function weexFactory (exports, document) {
    Severity: Major
    Found in packages/weex-vue-framework/factory.js - About 2 wks to fix

      Function createPatchFunction has 601 lines of code (exceeds 25 allowed). Consider refactoring.
      Open

      function createPatchFunction (backend) {
  var i, j;
  var cbs = {};

  var modules = backend.modules;
      Severity: Major
      Found in packages/weex-vue-framework/factory.js - About 3 days to fix

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

        function resolveAsyncComponent (
  factory,
  baseCtor
) {
  if (isTrue(factory.error) && isDef(factory.errorComp)) {
        Severity: Major
        Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

          Function enter has 95 lines of code (exceeds 25 allowed). Consider refactoring.
          Open

          function enter (_, vnode) {
  var el = vnode.elm;

  // call leave callback now
  if (el._leaveCb) {
          Severity: Major
          Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

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

            function eventsMixin (Vue) {
  var hookRE = /^hook:/;
  Vue.prototype.$on = function (event, fn) {
    var vm = this;
    if (Array.isArray(event)) {
            Severity: Major
            Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

              Function hydrate has 80 lines of code (exceeds 25 allowed). Consider refactoring.
              Open

                function hydrate (elm, vnode, insertedVnodeQueue, inVPre) {
    var i;
    var tag = vnode.tag;
    var data = vnode.data;
    var children = vnode.children;
              Severity: Major
              Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

                Function render has 77 lines of code (exceeds 25 allowed). Consider refactoring.
                Open

                  render: function render (h) {
    var this$1 = this;

    var children = this.$slots.default;
    if (!children) {
                Severity: Major
                Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

                  Function patch has 76 lines of code (exceeds 25 allowed). Consider refactoring.
                  Open

                    return function patch (oldVnode, vnode, hydrating, removeOnly) {
    if (isUndef(vnode)) {
      if (isDef(oldVnode)) { invokeDestroyHook(oldVnode); }
      return
    }
                  Severity: Major
                  Found in packages/weex-vue-framework/factory.js - About 3 hrs to fix

                    Function leave has 73 lines of code (exceeds 25 allowed). Consider refactoring.
                    Open

                    function leave (vnode, rm) {
  var el = vnode.elm;

  // call enter callback now
  if (el._enterCb) {
                    Severity: Major
                    Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                      function _createElement (
  context,
  tag,
  data,
  children,
                      Severity: Major
                      Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                          function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
    var oldStartIdx = 0;
    var newStartIdx = 0;
    var oldEndIdx = oldCh.length - 1;
    var oldStartVnode = oldCh[0];
                        Severity: Major
                        Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                          function lifecycleMixin (Vue) {
  Vue.prototype._update = function (vnode, hydrating) {
    var vm = this;
    var prevEl = vm.$el;
    var prevVnode = vm._vnode;
                          Severity: Major
                          Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                            function createComponent (
  Ctor,
  data,
  context,
  children,
                            Severity: Major
                            Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                function patchVnode (
    oldVnode,
    vnode,
    insertedVnodeQueue,
    ownerArray,
                              Severity: Major
                              Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                function mountComponent (
  vm,
  el,
  hydrating
) {
                                Severity: Major
                                Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                    function createElm (
    vnode,
    insertedVnodeQueue,
    parentElm,
    refElm,
                                  Severity: Major
                                  Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                    function renderMixin (Vue) {
  // install runtime convenience helpers
  installRenderHelpers(Vue.prototype);

  Vue.prototype.$nextTick = function (fn) {
                                    Severity: Major
                                    Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                      function _update (oldVnode, vnode) {
  var isCreate = oldVnode === emptyNode;
  var isDestroy = vnode === emptyNode;
  var oldDirs = normalizeDirectives$1(oldVnode.data.directives, oldVnode.context);
  var newDirs = normalizeDirectives$1(vnode.data.directives, vnode.context);
                                      Severity: Minor
                                      Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                        function FunctionalRenderContext (
  data,
  props,
  children,
  parent,
                                        Severity: Minor
                                        Found in packages/weex-vue-framework/factory.js - About 2 hrs to fix

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

                                          function initVirtualComponent (options) {
  if ( options === void 0 ) options = {};

  var vm = this;
  var componentId = options.componentId;
                                          Severity: Minor
                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                            function initExtend (Vue) {
  /**
   * Each instance constructor, including Vue, has a unique
   * cid. This enables us to create wrapped "child
   * constructors" for prototypal inheritance and cache them.
                                            Severity: Minor
                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                              function updateChildComponent (
  vm,
  propsData,
  listeners,
  parentVnode,
                                              Severity: Minor
                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                  Vue.prototype._render = function () {
    var vm = this;
    var ref = vm.$options;
    var render = ref.render;
    var _parentVnode = ref._parentVnode;
                                                Severity: Minor
                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                  Function defineReactive$$1 has 45 lines of code (exceeds 25 allowed). Consider refactoring.
                                                  Open

                                                  function defineReactive$$1 (
  obj,
  key,
  val,
  customSetter,
                                                  Severity: Minor
                                                  Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                    function stateMixin (Vue) {
  // flow somehow has problems with directly declared definition object
  // when using Object.defineProperty, so we have to procedurally build up
  // the object here.
  var dataDef = {};
                                                    Severity: Minor
                                                    Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                      Function initMixin has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                      Open

                                                      function initMixin (Vue) {
  Vue.prototype._init = function (options) {
    var vm = this;
    // a uid
    vm._uid = uid$3++;
                                                      Severity: Minor
                                                      Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                        Function Watcher has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                        Open

                                                        var Watcher = function Watcher (
  vm,
  expOrFn,
  cb,
  options,
                                                        Severity: Minor
                                                        Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                          Function extend has 42 lines of code (exceeds 25 allowed). Consider refactoring.
                                                          Open

                                                            Vue.extend = function (extendOptions) {
    extendOptions = extendOptions || {};
    var Super = this;
    var SuperId = Super.cid;
    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
                                                          Severity: Minor
                                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                            Consider simplifying this complex logical expression.
                                                            Open

                                                              if (process.env.NODE_ENV !== 'production') {
    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
    }, true);
    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
                                                            Severity: Critical
                                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                              function bindObjectProps (
  data,
  tag,
  value,
  asProp,
                                                              Severity: Minor
                                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                  Vue.prototype._init = function (options) {
    var vm = this;
    // a uid
    vm._uid = uid$3++;
                                                                Severity: Minor
                                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                  function assertProp (
  prop,
  name,
  value,
  vm,
                                                                  Severity: Minor
                                                                  Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                    function initProps (vm, propsOptions) {
  var propsData = vm.$options.propsData || {};
  var props = vm._props = {};
  // cache prop keys so that future props updates can iterate using Array
  // instead of dynamic object key enumeration.
                                                                    Severity: Minor
                                                                    Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                      function normalizeArrayChildren (children, nestedIndex) {
  var res = [];
  var i, c, lastIndex, last;
  for (i = 0; i < children.length; i++) {
    c = children[i];
                                                                      Severity: Minor
                                                                      Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                        function normalizeScopedSlots (
  slots,
  normalSlots,
  prevSlots
) {
                                                                        Severity: Minor
                                                                        Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                            render: function render (h) {
    var tag = this.tag || this.$vnode.data.tag || 'span';
    var map = Object.create(null);
    var prevChildren = this.prevChildren = this.children;
    var rawChildren = this.$slots.default || [];
                                                                          Severity: Minor
                                                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                            function initData (vm) {
  var data = vm.$options.data;
  data = vm._data = typeof data === 'function'
    ? getData(data, vm)
    : data || {};
                                                                            Severity: Minor
                                                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                              function flushSchedulerQueue () {
  currentFlushTimestamp = getNow();
  flushing = true;
  var watcher, id;
                                                                              Severity: Minor
                                                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                function mergeOptions (
  parent,
  child,
  vm
) {
                                                                                Severity: Minor
                                                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                  function renderList (
  val,
  render
) {
  var ret, i, l, keys, key;
                                                                                  Severity: Minor
                                                                                  Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                      render: function render () {
    var slot = this.$slots.default;
    var vnode = getFirstComponentChild(slot);
    var componentOptions = vnode && vnode.componentOptions;
    if (componentOptions) {
                                                                                    Severity: Minor
                                                                                    Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                      function updateListeners (
  on,
  oldOn,
  add,
  remove$$1,
                                                                                      Severity: Minor
                                                                                      Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                        function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass) {
  var targetState = {};
  var startState = stylesheet[startClass];
  var endState = stylesheet[endClass];
  var activeState = stylesheet[activeClass];
                                                                                        Severity: Minor
                                                                                        Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                          function initGlobalAPI (Vue) {
  // config
  var configDef = {};
  configDef.get = function () { return config; };
  if (process.env.NODE_ENV !== 'production') {
                                                                                          Severity: Minor
                                                                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                            function updateStyle (oldVnode, vnode) {
  if (!oldVnode.data.style && !vnode.data.style) {
    return
  }
  var cur, name;
                                                                                            Severity: Minor
                                                                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                              function extractPropsFromVNodeData (
  data,
  Ctor,
  tag
) {
                                                                                              Severity: Minor
                                                                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                function normalizeProps (options, vm) {
  var props = options.props;
  if (!props) { return }
  var res = {};
  var i, val, name;
                                                                                                Severity: Minor
                                                                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                  function updateAttrs (oldVnode, vnode) {
  if (!oldVnode.data.attrs && !vnode.data.attrs) {
    return
  }
  var key, cur, old;
                                                                                                  Severity: Minor
                                                                                                  Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                    function looseEqual (a, b) {
  if (a === b) { return true }
  var isObjectA = isObject(a);
  var isObjectB = isObject(b);
  if (isObjectA && isObjectB) {
                                                                                                    Severity: Minor
                                                                                                    Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                      function resolveSlots (
  children,
  context
) {
  if (!children || !children.length) {
                                                                                                      Severity: Minor
                                                                                                      Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                        function resolveInject (inject, vm) {
  if (inject) {
    // inject is :any because flow is not smart enough to figure out cached
    var result = Object.create(null);
    var keys = hasSymbol
                                                                                                        Severity: Minor
                                                                                                        Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                            Vue.prototype.$destroy = function () {
    var vm = this;
    if (vm._isBeingDestroyed) {
      return
    }
                                                                                                          Severity: Minor
                                                                                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                            function convertVNodeChildren (children) {
  if (!children.length) {
    return
  }
                                                                                                            Severity: Minor
                                                                                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                              function set (target, key, val) {
  if (process.env.NODE_ENV !== 'production' &&
    (isUndef(target) || isPrimitive(target))
  ) {
    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
                                                                                                              Severity: Minor
                                                                                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                  Vue.prototype.$off = function (event, fn) {
    var vm = this;
    // all
    if (!arguments.length) {
      vm._events = Object.create(null);
                                                                                                                Severity: Minor
                                                                                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                  function createFunctionalComponent (
  Ctor,
  propsData,
  data,
  contextVm,
                                                                                                                  Severity: Minor
                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                    function initComputed (vm, computed) {
  // $flow-disable-line
  var watchers = vm._computedWatchers = Object.create(null);
  // computed properties are just getters during SSR
  var isSSR = isServerRendering();
                                                                                                                    Severity: Minor
                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                      function validateProp (
  key,
  propOptions,
  propsData,
  vm
                                                                                                                      Severity: Minor
                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                        function mergeDataOrFn (
  parentVal,
  childVal,
  vm
) {
                                                                                                                        Severity: Minor
                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                            var loop = function ( key ) {
    keys.push(key);
    var value = validateProp(key, propsOptions, propsData, vm);
    /* istanbul ignore else */
    if (process.env.NODE_ENV !== 'production') {
                                                                                                                          Severity: Minor
                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                              function performLeave () {
    var animation = vnode.context.$requireWeexModule('animation');
    // the delayed leave may have already been cancelled
    if (cb.cancelled) {
      return
                                                                                                                            Severity: Minor
                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                              Open

                                                                                                                                      if (
          key === 'class' ||
          key === 'style' ||
          isReservedAttribute(key)
        ) {
                                                                                                                              Severity: Major
                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                                  tag,
  data,
  children,
  text,
  elm,
                                                                                                                                Severity: Major
                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 1 hr to fix

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

                                                                                                                                      vnode,
    insertedVnodeQueue,
    parentElm,
    refElm,
    nested,
                                                                                                                                  Severity: Major
                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 50 mins to fix

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

                                                                                                                                      context,
  tag,
  data,
  children,
  normalizationType,
                                                                                                                                    Severity: Minor
                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

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

                                                                                                                                        function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
                                                                                                                                      Severity: Minor
                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

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

                                                                                                                                          on,
  oldOn,
  add,
  remove$$1,
  createOnceHandler,
                                                                                                                                        Severity: Minor
                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

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

                                                                                                                                              oldVnode,
    vnode,
    insertedVnodeQueue,
    ownerArray,
    index,
                                                                                                                                          Severity: Minor
                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                            Open

                                                                                                                                                  for (i = 0, l = keys.length; i < l; i++) {
        key = keys[i];
        ret[i] = render(val[key], key, i);
      }
                                                                                                                                            Severity: Major
                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                              Open

                                                                                                                                                          for (var i = 0; i < cbs.destroy.length; ++i) {
              cbs.destroy[i](ancestor);
            }
                                                                                                                                              Severity: Major
                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                Open

                                                                                                                                                            if (patchable) {
              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
                cbs.create[i$1](emptyNode, ancestor);
              }
              // #6513
                                                                                                                                                Severity: Major
                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                  Open

                                                                                                                                                          if (isTrue(children._isVList) &&
          isDef(c.tag) &&
          isUndef(c.key) &&
          isDef(nestedIndex)) {
          c.key = "__vlist" + nestedIndex + "_" + i + "__";
                                                                                                                                                  Severity: Major
                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                    Open

                                                                                                                                                            if (isDef(res.timeout)) {
          timerTimeout = setTimeout(function () {
            timerTimeout = null;
            if (isUndef(factory.resolved)) {
              reject(
                                                                                                                                                    Severity: Major
                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                      Open

                                                                                                                                                            while (!result.done) {
        ret.push(render(result.value, ret.length));
        result = iterator.next();
      }
                                                                                                                                                      Severity: Major
                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                        Avoid deeply nested control flow statements.
                                                                                                                                                        Open

                                                                                                                                                                    if (i !== elm.innerHTML) {
              /* istanbul ignore if */
              if (process.env.NODE_ENV !== 'production' &&
                typeof console !== 'undefined' &&
                !hydrationBailed
                                                                                                                                                        Severity: Major
                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                          Avoid deeply nested control flow statements.
                                                                                                                                                          Open

                                                                                                                                                                      for (var i$1 = 0; i$1 < children.length; i$1++) {
              if (!childNode || !hydrate(childNode, children[i$1], insertedVnodeQueue, inVPre)) {
                childrenMatch = false;
                break
              }
                                                                                                                                                          Severity: Major
                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                            Avoid deeply nested control flow statements.
                                                                                                                                                            Open

                                                                                                                                                                    if (isDef(res.error)) {
          factory.errorComp = ensureCtor(res.error, baseCtor);
        }
                                                                                                                                                            Severity: Major
                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                              Avoid deeply nested control flow statements.
                                                                                                                                                              Open

                                                                                                                                                                          if (!childrenMatch || childNode) {
              /* istanbul ignore if */
              if (process.env.NODE_ENV !== 'production' &&
                typeof console !== 'undefined' &&
                !hydrationBailed
                                                                                                                                                              Severity: Major
                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                                Avoid deeply nested control flow statements.
                                                                                                                                                                Open

                                                                                                                                                                          if (last.constructor === vm.constructor) {
            currentRecursiveSequence++;
            vm = vm.$parent;
            continue
          } else if (currentRecursiveSequence > 0) {
                                                                                                                                                                Severity: Major
                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                                  Avoid deeply nested control flow statements.
                                                                                                                                                                  Open

                                                                                                                                                                                if (capture) { return }
                                                                                                                                                                  Severity: Major
                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                                    Avoid deeply nested control flow statements.
                                                                                                                                                                    Open

                                                                                                                                                                            if (isDef(res.loading)) {
          factory.loadingComp = ensureCtor(res.loading, baseCtor);
          if (res.delay === 0) {
            factory.loading = true;
          } else {
                                                                                                                                                                    Severity: Major
                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                                      Avoid deeply nested control flow statements.
                                                                                                                                                                      Open

                                                                                                                                                                                  if (hydrate(oldVnode, vnode, insertedVnodeQueue)) {
              invokeInsertHook(vnode, insertedVnodeQueue, true);
              return oldVnode
            } else if (process.env.NODE_ENV !== 'production') {
              warn(
                                                                                                                                                                      Severity: Major
                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 45 mins to fix

                                                                                                                                                                        Consider simplifying this complex logical expression.
                                                                                                                                                                        Open

                                                                                                                                                                        if (process.env.NODE_ENV !== 'production') {
  var allowedGlobals = makeMap(
    'Infinity,undefined,NaN,isFinite,isNaN,' +
    'parseFloat,parseInt,decodeURI,decodeURIComponent,encodeURI,encodeURIComponent,' +
    'Math,Number,Date,Array,Object,Boolean,String,RegExp,Map,Set,JSON,Intl,' +
                                                                                                                                                                        Severity: Major
                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                          Consider simplifying this complex logical expression.
                                                                                                                                                                          Open

                                                                                                                                                                              if ((child.context === context || child.fnContext === context) &&
      data && data.slot != null
    ) {
      var name = data.slot;
      var slot = (slots[name] || (slots[name] = []));
                                                                                                                                                                          Severity: Major
                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                            Consider simplifying this complex logical expression.
                                                                                                                                                                            Open

                                                                                                                                                                                  if (
        process.env.NODE_ENV !== 'production' &&
        targetState[key] == null &&
        (!activeState || activeState[key] == null) &&
        (!endState || endState[key] == null)
                                                                                                                                                                            Severity: Major
                                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                              Consider simplifying this complex logical expression.
                                                                                                                                                                              Open

                                                                                                                                                                                } else if (
    isStable &&
    prevSlots &&
    prevSlots !== emptyObject &&
    key === prevSlots.$key &&
                                                                                                                                                                              Severity: Major
                                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                                Consider simplifying this complex logical expression.
                                                                                                                                                                                Open

                                                                                                                                                                                    if (
      oldChild &&
      oldChild.data &&
      !isSameChild(child, oldChild) &&
      !isAsyncPlaceholder(oldChild) &&
                                                                                                                                                                                Severity: Major
                                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                                  Consider simplifying this complex logical expression.
                                                                                                                                                                                  Open

                                                                                                                                                                                        if (
        // not included
        (include && (!name || !matches(include, name))) ||
        // excluded
        (exclude && name && matches(exclude, name))
                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

                                                                                                                                                                                    Consider simplifying this complex logical expression.
                                                                                                                                                                                    Open

                                                                                                                                                                                      } else if (
    shouldObserve &&
    !isServerRendering() &&
    (Array.isArray(value) || isPlainObject(value)) &&
    Object.isExtensible(value) &&
                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 40 mins to fix

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

                                                                                                                                                                                        handler,
  context,
  args,
  vm,
  info
                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                          eventKeyCode,
  key,
  builtInKeyCode,
  eventKeyName,
  builtInKeyName
                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                          function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                              factory,
  data,
  context,
  children,
  tag
                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                data,
  tag,
  value,
  asProp,
  isSync
                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                  res,
  hash,
  key,
  altKey,
  preserve
                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

                                                                                                                                                                                                  Function add$1 has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                  Open

                                                                                                                                                                                                    event,
  handler,
  capture,
  passive,
  params
                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                      prop,
  name,
  value,
  vm,
  absent
                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                        Ctor,
  data,
  context,
  children,
  tag
                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

                                                                                                                                                                                                        Function defineReactive$$1 has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                        Open

                                                                                                                                                                                                          obj,
  key,
  val,
  customSetter,
  shallow
                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                            Ctor,
  propsData,
  data,
  contextVm,
  children
                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                              data,
  props,
  children,
  parent,
  Ctor
                                                                                                                                                                                                            Severity: Minor
                                                                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                                vm,
  propsData,
  listeners,
  parentVnode,
  renderChildren
                                                                                                                                                                                                              Severity: Minor
                                                                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                                function getEnterTargetState (el, stylesheet, startClass, endClass, activeClass) {
                                                                                                                                                                                                                Severity: Minor
                                                                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                                    context,
  tag,
  data,
  children,
  normalizationType
                                                                                                                                                                                                                  Severity: Minor
                                                                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                                      vm,
  expOrFn,
  cb,
  options,
  isRenderWatcher
                                                                                                                                                                                                                    Severity: Minor
                                                                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

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

                                                                                                                                                                                                                        function updateChildren (parentElm, oldCh, newCh, insertedVnodeQueue, removeOnly) {
                                                                                                                                                                                                                      Severity: Minor
                                                                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

                                                                                                                                                                                                                        Function callHook$1 has 5 arguments (exceeds 4 allowed). Consider refactoring.
                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                        function callHook$1 (dir, hook, vnode, oldVnode, isDestroy) {
                                                                                                                                                                                                                        Severity: Minor
                                                                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 35 mins to fix

                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                  return placeholder(h, rawChild)
                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                return String(a) === String(b)
                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                  return rawChild
                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                              return false
                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                    return vnode
                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                              return oldRawChild
                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                        return val
                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                            return createEmptyVNode()
                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                          Avoid too many return statements within this function.
                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                            return res
                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                            Avoid too many return statements within this function.
                                                                                                                                                                                                                                            Open

                                                                                                                                                                                                                                                return renderRecyclableComponentTemplate(vnode)
                                                                                                                                                                                                                                            Severity: Major
                                                                                                                                                                                                                                            Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                              Avoid too many return statements within this function.
                                                                                                                                                                                                                                              Open

                                                                                                                                                                                                                                                    return false
                                                                                                                                                                                                                                              Severity: Major
                                                                                                                                                                                                                                              Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                                Avoid too many return statements within this function.
                                                                                                                                                                                                                                                Open

                                                                                                                                                                                                                                                    return vm
                                                                                                                                                                                                                                                Severity: Major
                                                                                                                                                                                                                                                Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                                  Avoid too many return statements within this function.
                                                                                                                                                                                                                                                  Open

                                                                                                                                                                                                                                                      return true
                                                                                                                                                                                                                                                  Severity: Major
                                                                                                                                                                                                                                                  Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                                    Avoid too many return statements within this function.
                                                                                                                                                                                                                                                    Open

                                                                                                                                                                                                                                                        return false
                                                                                                                                                                                                                                                    Severity: Major
                                                                                                                                                                                                                                                    Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                                      Avoid too many return statements within this function.
                                                                                                                                                                                                                                                      Open

                                                                                                                                                                                                                                                            return placeholder(h, rawChild)
                                                                                                                                                                                                                                                      Severity: Major
                                                                                                                                                                                                                                                      Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

                                                                                                                                                                                                                                                        Avoid too many return statements within this function.
                                                                                                                                                                                                                                                        Open

                                                                                                                                                                                                                                                                return false
                                                                                                                                                                                                                                                        Severity: Major
                                                                                                                                                                                                                                                        Found in packages/weex-vue-framework/factory.js - About 30 mins to fix

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

                                                                                                                                                                                                                                                              if (isUndef(oldVnode)) {
      // empty mount (likely as component), create new root element
      isInitialPatch = true;
      createElm(vnode, insertedVnodeQueue);
    } else {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 709..798

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function FunctionalRenderContext (
  data,
  props,
  children,
  parent,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 days to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8133..8205
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7883..7955

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

                                                                                                                                                                                                                                                          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 (isDef(tag)) {
      if (isDef(children)) {
        // empty element, allow client to pick up and populate children
        if (!elm.hasChildNodes()) {
          createChildren(vnode, children, insertedVnodeQueue);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 days to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 620..685

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 520.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function normalizeArrayChildren (children, nestedIndex) {
  var res = [];
  var i, c, lastIndex, last;
  for (i = 0; i < children.length; i++) {
    c = children[i];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6684..6730
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6434..6480

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            Vue.extend = function (extendOptions) {
    extendOptions = extendOptions || {};
    var Super = this;
    var SuperId = Super.cid;
    var cachedCtors = extendOptions._Ctor || (extendOptions._Ctor = {});
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 days to fix
                                                                                                                                                                                                                                                          src/core/global-api/extend.js on lines 19..80

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function defineReactive$$1 (
  obj,
  key,
  val,
  customSetter,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2884..2943
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1234..1293

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function renderList (
  val,
  render
) {
  var ret, i, l, keys, key;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7217..7255
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6967..7005

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 446.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function resolveSlots (
  children,
  context
) {
  if (!children || !children.length) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 days to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7558..7596
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7308..7346

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function normalizeScopedSlots (
  slots,
  normalSlots,
  prevSlots
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7610..7658
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7360..7408

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function looseEqual (a, b) {
  if (a === b) { return true }
  var isObjectA = isObject(a);
  var isObjectB = isObject(b);
  if (isObjectA && isObjectB) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 274..307
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 276..309

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createFunctionalComponent (
  Ctor,
  propsData,
  data,
  contextVm,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8209..8248
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7959..7998

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function mergeOptions (
  parent,
  child,
  vm
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/util/options.js on lines 388..435

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function updateAttrs (oldVnode, vnode) {
  if (!oldVnode.data.attrs && !vnode.data.attrs) {
    return
  }
  var key, cur, old;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/attrs.js on lines 5..39

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

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

                                                                                                                                                                                                                                                          var VNode = function VNode (
  tag,
  data,
  children,
  text,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2684..2717
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 529..562
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 531..564
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1070..1103
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1034..1067

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function set (target, key, val) {
  if (process.env.NODE_ENV !== 'production' &&
    (isUndef(target) || isPrimitive(target))
  ) {
    warn(("Cannot set reactive property on undefined, null, or primitive value: " + ((target))));
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2950..2980
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1300..1330

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function removeAndInvokeRemoveHook (vnode, rm) {
    if (isDef(rm) || isDef(vnode.data)) {
      var i;
      var listeners = cbs.remove.length + 1;
      if (isDef(rm)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 375..402

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function performLeave () {
    var animation = vnode.context.$requireWeexModule('animation');
    // the delayed leave may have already been cancelled
    if (cb.cancelled) {
      return
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 195..228

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          strats.watch = function (
  parentVal,
  childVal,
  vm,
  key
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3182..3210
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1532..1560

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 255.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function transformModel (options, data) {
  var prop = (options.model && options.model.prop) || 'value';
  var event = (options.model && options.model.event) || 'input'
  ;(data.attrs || (data.attrs = {}))[prop] = data.model.value;
  var on = data.on || (data.on = {});
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8490..8508
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 8240..8258

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            setTimeout(function () {
    var parent = el.parentNode;
    var pendingNode = parent && parent._pending && parent._pending[vnode.key];
    if (pendingNode &&
      pendingNode.context === vnode.context &&
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 93..116

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 233.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function mergeVNodeHook (def, hookKey, hook) {
  if (def instanceof VNode) {
    def = def.data.hook || (def.data.hook = {});
  }
  var invoker;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/vdom/helpers/merge-hook.js on lines 7..38

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function _traverse (val, seen) {
  var i, keys;
  var isA = Array.isArray(val);
  if ((!isA && !isObject(val)) || Object.isFrozen(val) || val instanceof VNode) {
    return
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6898..6919
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6648..6669

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function cloneVNode (vnode) {
  var cloned = new VNode(
    vnode.tag,
    vnode.data,
    // #7975
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 591..615
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 593..617

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function initLifecycle (vm) {
  var options = vm.$options;

  // locate first non-abstract parent
  var parent = options.parent;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/instance/lifecycle.js on lines 32..56

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function setScope (vnode) {
    var i;
    if (isDef(i = vnode.fnScopeId)) {
      nodeOps.setStyleScope(vnode.elm, i);
    } else {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 318..339

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function mergeDataOrFn (
  parentVal,
  childVal,
  vm
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3053..3093
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1361..1401
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1363..1403
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1438..1478
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1403..1443

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function getPropDefaultValue (vm, prop, key) {
  // no default, return undefined
  if (!hasOwn(prop, 'default')) {
    return undefined
  }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/util/props.js on lines 67..95

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 206.

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function mergeData (to, from) {
  if (!from) { return to }
  var key, toVal, fromVal;

  var keys = hasSymbol
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3023..3048
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1331..1356
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1333..1358
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1408..1433
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1373..1398

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          methodsToPatch.forEach(function (method) {
  // cache original method
  var original = arrayProto[method];
  def(arrayMethods, method, function mutator () {
    var args = [], len = arguments.length;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 day to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2750..2774
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1055..1079
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1057..1081
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1136..1160
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1100..1124

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function queueWatcher (watcher) {
  var id = watcher.id;
  if (has[id] == null) {
    has[id] = true;
    if (!flushing) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/observer/scheduler.js on lines 164..190

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                              Vue[type] = function (
      id,
      definition
    ) {
      if (!definition) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 day to fix
                                                                                                                                                                                                                                                          src/core/global-api/assets.js on lines 11..32

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function initInternalComponent (vm, options) {
  var opts = vm.$options = Object.create(vm.constructor.options);
  // doing this because it's faster than dynamic enumeration.
  var parentVnode = options._parentVnode;
  opts.parent = options.parent;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/init.js on lines 74..91

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function handleError (err, vm, info) {
  // Deactivate deps tracking while processing error handler to avoid possible infinite rendering.
  // See: https://github.com/vuejs/vuex/issues/1505
  pushTarget();
  try {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 7 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1985..2010
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1987..2012

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 182.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Watcher.prototype.cleanupDeps = function cleanupDeps () {
  var i = this.deps.length;
  while (i--) {
    var dep = this.deps[i];
    if (!this.newDepIds.has(dep.id)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 7 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 143..159

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 182.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function applyNS (vnode, ns, force) {
  vnode.ns = ns;
  if (vnode.tag === 'foreignObject') {
    // use default namespace inside foreignObject
    ns = undefined;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 3 other locations - About 7 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/create-element.js on lines 138..154
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7182..7198
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6932..6948

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function resolveScopedSlots (
  fns, // see flow/vnode
  res,
  // the following are added in 2.6
  hasDynamicKeys,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 7 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7478..7502
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7228..7252

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

                                                                                                                                                                                                                                                          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 (isRemoval) {
    if (Array.isArray(refs[key])) {
      remove(refs[key], ref);
    } else if (refs[key] === ref) {
      refs[key] = undefined;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/modules/ref.js on lines 27..44

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createStyle (oldVnode, vnode) {
  if (!vnode.data.staticStyle) {
    updateStyle(oldVnode, vnode);
    return
  }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/style.js on lines 7..27

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function createComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
    var i = vnode.data;
    if (isDef(i)) {
      var isReactivated = isDef(vnode.componentInstance) && i.keepAlive;
      if (isDef(i = i.hook) && isDef(i = i.init)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 210..230

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 172.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function reactivateComponent (vnode, insertedVnodeQueue, parentElm, refElm) {
    var i;
    // hack for #4339: a reactivated component with inner transition
    // does not trigger because the inner node's created hooks are not called
    // again. It's not ideal to involve module-specific logic in here but
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 250..270

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function observe (value, asRootData) {
  if (!isObject(value) || value instanceof VNode) {
    return
  }
  var ob;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 6 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2859..2879
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1168..1188
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1170..1190
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1245..1265
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1209..1229

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          var normalizeEvent = cached(function (name) {
  var passive = name.charAt(0) === '&';
  name = passive ? name.slice(1) : name;
  var once$$1 = name.charAt(0) === '~'; // Prefixed last, checked first
  name = once$$1 ? name.slice(1) : name;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 6 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6935..6948
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6685..6698

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            for (key in newDirs) {
    oldDir = oldDirs[key];
    dir = newDirs[key];
    if (!oldDir) {
      // new directive, bind
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/modules/directives.js on lines 31..49

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 166.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (!type) {
      props.type = 'span';
      props.attr = {
        value: (vnode.text || '').trim()
      };
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 6 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/richtext.js on lines 44..62

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Dep.prototype.notify = function notify () {
  // stabilize the subscriber list first
  var subs = this.subs.slice();
  if (process.env.NODE_ENV !== 'production' && !config.async) {
    // subs aren't sorted in scheduler if not running async
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 6 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2663..2675
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1013..1025

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function invokeWithErrorHandling (
  handler,
  context,
  args,
  vm,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 6 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 2012..2032
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 2014..2034

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function bindObjectListeners (data, value) {
  if (value) {
    if (!isPlainObject(value)) {
      process.env.NODE_ENV !== 'production' && warn(
        'v-on without argument expects an Object value',
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/render-helpers/bind-object-listeners.js on lines 5..22

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            Vue.use = function (plugin) {
    var installedPlugins = (this._installedPlugins || (this._installedPlugins = []));
    if (installedPlugins.indexOf(plugin) > -1) {
      return this
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/global-api/use.js on lines 6..22

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 152.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function normalizeDirectives$1 (
  dirs,
  vm
) {
  var res = Object.create(null);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/modules/directives.js on lines 84..105

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function createChildren (vnode, children, insertedVnodeQueue) {
    if (Array.isArray(children)) {
      if (process.env.NODE_ENV !== 'production') {
        checkDuplicateKeys(children);
      }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 284..295

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function cloneAndMarkFunctionalResult (vnode, data, contextVm, options, renderContext) {
  // #7817 clone node before setting fnContext, otherwise if the node is reused
  // (e.g. it was from a cached normal slot) the fnContext causes named slots
  // that should not be matched to match.
  var clone = cloneVNode(vnode);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/create-functional-component.js on lines 135..149

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function initComponent (vnode, insertedVnodeQueue) {
    if (isDef(vnode.data.pendingInsert)) {
      insertedVnodeQueue.push.apply(insertedVnodeQueue, vnode.data.pendingInsert);
      vnode.data.pendingInsert = null;
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 232..248

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function activateChildComponent (vm, direct) {
  if (direct) {
    vm._directInactive = false;
    if (isInInactiveTree(vm)) {
      return
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7964..7980
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7714..7730

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function installComponentHooks (data) {
  var hooks = data.hook || (data.hook = {});
  for (var i = 0; i < hooksToMerge.length; i++) {
    var key = hooksToMerge[i];
    var existing = hooks[key];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8466..8476
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 8216..8226

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

                                                                                                                                                                                                                                                          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 (options) {
    this.deep = !!options.deep;
    this.user = !!options.user;
    this.lazy = !!options.lazy;
    this.sync = !!options.sync;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 59..67

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createFnInvoker (fns, vm) {
  function invoker () {
    var arguments$1 = arguments;

    var fns = invoker.fns;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6950..6967
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6700..6717

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

                                                                                                                                                                                                                                                          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 (!vm.$options.render) {
    vm.$options.render = createEmptyVNode;
    if (process.env.NODE_ENV !== 'production') {
      /* istanbul ignore if */
      if ((vm.$options.template && vm.$options.template.charAt(0) !== '#') ||
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/lifecycle.js on lines 147..166

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 136.

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function renderStatic (
  index,
  isInFor
) {
  var cached = this._staticTrees || (this._staticTrees = []);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 5 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7399..7418
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7149..7168

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

                                                                                                                                                                                                                                                          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 (Array.isArray(event)) {
      for (var i = 0, l = event.length; i < l; i++) {
        vm.$on(event[i], fn);
      }
    } else {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 5 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 56..67

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          var Observer = function Observer (value) {
  this.value = value;
  this.dep = new Dep();
  this.vmCount = 0;
  def(value, '__ob__', this);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2792..2807
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1101..1116
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1103..1118
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1178..1193
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1142..1157

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 133.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          strats.props =
strats.methods =
strats.inject =
strats.computed = function (
  parentVal,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3215..3232
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1565..1582

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function makeMap (
  str,
  expectsLowerCase
) {
  var map = Object.create(null);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 70..82
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 108..120
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 110..122
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 114..126
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 71..83

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

                                                                                                                                                                                                                                                          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 (isUndef(idxInOld)) { // New element
          createElm(newStartVnode, insertedVnodeQueue, parentElm, oldStartVnode.elm, false, newCh, newStartIdx);
        } else {
          vnodeToMove = oldCh[idxInOld];
          if (sameVnode(vnodeToMove, newStartVnode)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 452..464

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            if (typeof userDef === 'function') {
    sharedPropertyDefinition.get = shouldCache
      ? createComputedGetter(key)
      : createGetterInvoker(userDef);
    sharedPropertyDefinition.set = noop;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 219..231

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            for (i = 0; i < hooks.length; ++i) {
    cbs[hooks[i]] = [];
    for (j = 0; j < modules.length; ++j) {
      if (isDef(modules[j][hooks[i]])) {
        cbs[hooks[i]].push(modules[j][hooks[i]]);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 76..83

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function assertNodeMatch (node, vnode, inVPre) {
    if (isDef(vnode.tag)) {
      return vnode.tag.indexOf('vue-component') === 0 || (
        !isUnknownElement$$1(vnode, inVPre) &&
        vnode.tag.toLowerCase() === (node.tagName && node.tagName.toLowerCase())
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 689..698

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 119.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function deactivateChildComponent (vm, direct) {
  if (direct) {
    vm._directInactive = true;
    if (isInInactiveTree(vm)) {
      return
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7982..7996
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7732..7746

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function insertBefore (
  node,
  target,
  before
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/node-ops.js on lines 24..41

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                {
        // in Weex, the default insertion order is parent-first.
        // List items can be optimized to use children-first insertion
        // with append="tree".
        var appendAsTree = isDef(data) && isTrue(data.appendAsTree);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 172..190

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function dependArray (value) {
  for (var e = (void 0), i = 0, l = value.length; i < l; i++) {
    e = value[i];
    e && e.__ob__ && e.__ob__.dep.depend();
    if (Array.isArray(e)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 4 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2986..2994
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1294..1302
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1296..1304
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1371..1379
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1336..1344

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 116.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function appendChild (node, child) {
  if (child.nodeType === 3) {
    if (node.type === 'text') {
      node.setAttr('value', child.text);
      child.parentNode = node;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/node-ops.js on lines 51..65

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            updated: function updated () {
    var children = this.prevChildren;
    var moveClass = this.moveClass || ((this.name || 'v') + '-move');
    var moveData = children.length && this.getMoveData(children[0].context, moveClass);
    if (!moveData) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 4 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/transition-group.js on lines 89..129

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function invokeInsertHook (vnode, queue, initial) {
    // delay insert hooks for component root nodes, invoke them after the
    // element is really inserted
    if (isTrue(initial) && isDef(vnode.parent)) {
      vnode.parent.data.pendingInsert = queue;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 576..586

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 114.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function markStatic (
  tree,
  key,
  isOnce
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7433..7447
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7183..7197

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function updateDOMListeners (oldVnode, vnode) {
  if (!oldVnode.data.on && !vnode.data.on) {
    return
  }
  var on = vnode.data.on || {};
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/events.js on lines 40..49

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function resolveTransition (def$$1) {
  if (!def$$1) {
    return
  }
  /* istanbul ignore else */
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/transition-util.js on lines 7..22

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Watcher.prototype.teardown = function teardown () {
  if (this.active) {
    // remove self from vm's watcher list
    // this is a somewhat expensive operation so we skip it
    // if the vm is being destroyed.
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 226..240

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

                                                                                                                                                                                                                                                          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 el.setClassList === 'function') {
    el.setClassList(classList);
  } else {
    var style = getStyle(oldClassList, classList, ctx);
    if (typeof el.setStyles === 'function') {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/class.js on lines 21..32

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function matches (pattern, name) {
  if (Array.isArray(pattern)) {
    return pattern.indexOf(name) > -1
  } else if (typeof pattern === 'string') {
    return pattern.split(',').indexOf(name) > -1
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/components/keep-alive.js on lines 18..28

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

                                                                                                                                                                                                                                                          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 cb = el._leaveCb = once(function () {
    if (el.parentNode && el.parentNode._pending) {
      el.parentNode._pending[vnode.key] = null;
    }
    if (cb.cancelled) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 176..187

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          if (inBrowser && !isIE) {
  var performance = window.performance;
  if (
    performance &&
    typeof performance.now === 'function' &&
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8025..8038
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7775..7788

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            if (Array.isArray(props)) {
    i = props.length;
    while (i--) {
      val = props[i];
      if (typeof val === 'string') {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/util/options.js on lines 303..328

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                              child.key = child.key == null
      ? child.isComment
        ? id + 'comment'
        : id + child.tag
      : isPrimitive(child.key)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 146..152

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function validateComponentName (name) {
  if (!new RegExp(("^[a-zA-Z][\\-\\.0-9_" + (unicodeRegExp.source) + "]*$")).test(name)) {
    warn(
      'Invalid component name: "' + name + '". Component names ' +
      'should conform to valid custom element name in html5 specification.'
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1561..1574
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1563..1576

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

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

                                                                                                                                                                                                                                                          var isServerRendering = function () {
  if (_isServer === undefined) {
    /* istanbul ignore if */
    if (!inBrowser && !inWeex && typeof global !== 'undefined') {
      // detect presence of vue-server-renderer and avoid
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 881..893
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 719..731
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 721..733
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 766..778
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 724..736

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function getTypeIndex (type, expectedTypes) {
  if (!Array.isArray(expectedTypes)) {
    return isSameType(expectedTypes, type) ? 0 : -1
  }
  for (var i = 0, len = expectedTypes.length; i < len; i++) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1927..1937
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1929..1939

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 99.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          strats.data = function (
  parentVal,
  childVal,
  vm
) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3095..3115
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1445..1465

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 99.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createComputedGetter (key) {
  return function computedGetter () {
    var watcher = this._computedWatchers && this._computedWatchers[key];
    if (watcher) {
      if (watcher.dirty) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 244..257

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Watcher.prototype.addDep = function addDep (dep) {
  var id = dep.id;
  if (!this.newDepIds.has(id)) {
    this.newDepIds.add(id);
    this.newDeps.push(dep);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 129..138

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function simpleNormalizeChildren (children) {
  for (var i = 0; i < children.length; i++) {
    if (Array.isArray(children[i])) {
      return Array.prototype.concat.apply([], children)
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6659..6666
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6409..6416

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function polyfillBind (fn, ctx) {
  function boundFn (a) {
    var l = arguments.length;
    return l
      ? l > 1
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 3 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 150..162
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 195..207
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 197..209
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 194..206
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 151..163

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function initWatch (vm, watch) {
  for (var key in watch) {
    var handler = watch[key];
    if (Array.isArray(handler)) {
      for (var i = 0; i < handler.length; i++) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 293..304

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            initProxy = function initProxy (vm) {
    if (hasProxy) {
      // determine which proxy handler to use
      var options = vm.$options;
      var handlers = options.render && options.render._withStripped
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 3 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/proxy.js on lines 78..89

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function callUpdatedHooks (queue) {
  var i = queue.length;
  while (i--) {
    var watcher = queue[i];
    var vm = watcher.vm;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/scheduler.js on lines 130..139

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            function removeVnodes (vnodes, startIdx, endIdx) {
    for (; startIdx <= endIdx; ++startIdx) {
      var ch = vnodes[startIdx];
      if (isDef(ch)) {
        if (isDef(ch.tag)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 361..373

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

                                                                                                                                                                                                                                                          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 (isDef(tag)) {
      if (process.env.NODE_ENV !== 'production') {
        if (data && data.pre) {
          creatingElmInVPre++;
        }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 151..207

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function getFirstComponentChild (children) {
  if (Array.isArray(children)) {
    for (var i = 0; i < children.length; i++) {
      var c = children[i];
      if (isDef(c) && (isDef(c.componentOptions) || isAsyncPlaceholder(c))) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/helpers/get-first-component-child.js on lines 6..15

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 91.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createElement (
  context,
  tag,
  data,
  children,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7085..7102
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6835..6852

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function flushCallbacks () {
  pending = false;
  var copies = callbacks.slice(0);
  callbacks.length = 0;
  for (var i = 0; i < copies.length; i++) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/util/next-tick.js on lines 13..20

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

                                                                                                                                                                                                                                                          function normalizeDirectives (options) {
  var dirs = options.directives;
  if (dirs) {
    for (var key in dirs) {
      var def$$1 = dirs[key];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1644..1654
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1646..1656

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

                                                                                                                                                                                                                                                          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 (isTrue(vnode.isStatic) &&
      isTrue(oldVnode.isStatic) &&
      vnode.key === oldVnode.key &&
      (isTrue(vnode.isCloned) || isTrue(vnode.isOnce))
    ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 533..540

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function dedupeHooks (hooks) {
  var res = [];
  for (var i = 0; i < hooks.length; i++) {
    if (res.indexOf(hooks[i]) === -1) {
      res.push(hooks[i]);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 6 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3136..3144
                                                                                                                                                                                                                                                          src/core/util/options.js on lines 162..170
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1444..1452
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1446..1454
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1521..1529
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1486..1494

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          if (process.env.NODE_ENV !== 'production') {
  strats.el = strats.propsData = function (parent, child, vm, key) {
    if (!vm) {
      warn(
        "option \"" + key + "\" can only be used during instance " +
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3008..3018
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1358..1368

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function globalHandleError (err, vm, info) {
  if (config.errorHandler) {
    try {
      return config.errorHandler.call(null, err, vm, info)
    } catch (e) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/util/error.js on lines 58..71

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function resetSchedulerState () {
  index = queue.length = activatedChildren.length = 0;
  has = {};
  if (process.env.NODE_ENV !== 'production') {
    circular = {};
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/observer/scheduler.js on lines 28..35

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                              if (config.isReservedTag(tag)) {
      // platform built-in elements
      if (process.env.NODE_ENV !== 'production' && isDef(data) && isDef(data.nativeOn)) {
        warn(
          ("The .native modifier for v-on is only valid on components but it was used on <" + tag + ">."),
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/create-element.js on lines 99..122

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 83.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Observer.prototype.walk = function walk (obj) {
  var keys = Object.keys(obj);
  for (var i = 0; i < keys.length; i++) {
    defineReactive$$1(obj, keys[i]);
  }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2814..2819
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1123..1128
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1125..1130
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1200..1205
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1164..1169

                                                                                                                                                                                                                                                          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 (oldStartIdx > oldEndIdx) {
      refElm = isUndef(newCh[newEndIdx + 1]) ? null : newCh[newEndIdx + 1].elm;
      addVnodes(parentElm, refElm, newCh, newStartIdx, newEndIdx, insertedVnodeQueue);
    } else if (newStartIdx > newEndIdx) {
      removeVnodes(oldCh, oldStartIdx, oldEndIdx);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 468..473

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            function insert (parent, elm, ref$$1) {
    if (isDef(parent)) {
      if (isDef(ref$$1)) {
        if (nodeOps.parentNode(ref$$1) === parent) {
          nodeOps.insertBefore(parent, elm, ref$$1);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 272..282

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

                                                                                                                                                                                                                                                          function mergeAssets (
  parentVal,
  childVal,
  vm,
  key
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3157..3170
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1507..1520

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 80.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function proxy (target, sourceKey, key) {
  sharedPropertyDefinition.get = function proxyGetter () {
    return this[sourceKey][key]
  };
  sharedPropertyDefinition.set = function proxySetter (val) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 39..47

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 80.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function isBoolean () {
  var args = [], len = arguments.length;
  while ( len-- ) args[ len ] = arguments[ len ];

  return args.some(function (elem) { return elem.toLowerCase() === 'boolean'; })
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1976..1981
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1978..1983

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

                                                                                                                                                                                                                                                          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 (process.env.NODE_ENV !== 'production') {
        if (data && data.pre) {
          creatingElmInVPre++;
        }
        if (isUnknownElement$$1(vnode, creatingElmInVPre)) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 152..164

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                } else if (sameVnode(oldStartVnode, newEndVnode)) { // Vnode moved right
        patchVnode(oldStartVnode, newEndVnode, insertedVnodeQueue, newCh, newEndIdx);
        canMove && nodeOps.insertBefore(parentElm, oldStartVnode.elm, nodeOps.nextSibling(oldEndVnode.elm));
        oldStartVnode = oldCh[++oldStartIdx];
        newEndVnode = newCh[--newEndIdx];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 2 hrs to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 437..466

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

                                                                                                                                                                                                                                                          if (inBrowser) {
  try {
    var opts = {};
    Object.defineProperty(opts, 'passive', ({
      get: function get () {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 867..876
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 705..714
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 707..716
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 752..761
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 710..719

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function toObject (arr) {
  var res = {};
  for (var i = 0; i < arr.length; i++) {
    if (arr[i]) {
      extend(res, arr[i]);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 230..238
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 232..240

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function ensureCtor (comp, base) {
  if (
    comp.__esModule ||
    (hasSymbol && comp[Symbol.toStringTag] === 'Module')
  ) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 2 hrs to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7696..7706
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7446..7456

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function toString (val) {
  return val == null
    ? ''
    : Array.isArray(val) || (isPlainObject(val) && val.toString === _toString)
      ? JSON.stringify(val, null, 2)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 87..93
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 89..95

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 74.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function copyAugment (target, src, keys) {
  for (var i = 0, l = keys.length; i < l; i++) {
    var key = keys[i];
    def(target, key, src[key]);
  }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2847..2852
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1156..1161
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1158..1163
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1233..1238
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1197..1202

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 72.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          Observer.prototype.observeArray = function observeArray (items) {
  for (var i = 0, l = items.length; i < l; i++) {
    observe(items[i]);
  }
};
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2824..2828
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1133..1137
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1135..1139
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1210..1214
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1174..1178

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 71.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          var nodeOps = /*#__PURE__*/Object.freeze({
  namespaceMap: namespaceMap,
  createElement: createElement$1,
  createElementNS: createElementNS,
  createTextNode: createTextNode,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 31..46

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 71.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createWatcher (
  vm,
  expOrFn,
  handler,
  options
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 306..320

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (!(vnode instanceof VNode)) {
      if (process.env.NODE_ENV !== 'production' && Array.isArray(vnode)) {
        warn(
          'Multiple root nodes returned from render function. Render function ' +
          'should return a single root node.',
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/render.js on lines 115..124

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function toObject$1 (arr) {
  var res = {};
  for (var i = 0; i < arr.length; i++) {
    if (arr[i]) {
      extend(res, arr[i]);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/style.js on lines 71..79

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (Array.isArray(event)) {
      for (var i$1 = 0, l = event.length; i$1 < l; i$1++) {
        vm.$off(event[i$1], fn);
      }
      return vm
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 90..95

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 70.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createAsyncPlaceholder (
  factory,
  data,
  context,
  children,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7708..7719
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7458..7469

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function cached (fn) {
  var cache = Object.create(null);
  return (function cachedFn (str) {
    var hit = cache[str];
    return hit || (cache[str] = fn(str))
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 117..123
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 155..161
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 157..163
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 161..167
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 118..124

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createOnceHandler$1 (event, handler, capture) {
  var _target = target$1; // save current target element in closure
  return function onceHandler () {
    var res = handler.apply(null, arguments);
    if (res !== null) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/events.js on lines 7..15

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function mergeHook (
  parentVal,
  childVal
) {
  var res = childVal
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 3120..3134
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1428..1442
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1430..1444
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1505..1519
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1470..1484

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

                                                                                                                                                                                                                                                          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 (!prevVnode) {
      // initial render
      vm.$el = vm.__patch__(vm.$el, vnode, hydrating, false /* removeOnly */);
    } else {
      // updates
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/lifecycle.js on lines 67..73

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                } else if (sameVnode(oldEndVnode, newStartVnode)) { // Vnode moved left
        patchVnode(oldEndVnode, newStartVnode, insertedVnodeQueue, newCh, newStartIdx);
        canMove && nodeOps.insertBefore(parentElm, oldEndVnode.elm, oldStartVnode.elm);
        oldEndVnode = oldCh[--oldEndIdx];
        newStartVnode = newCh[++newStartIdx];
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 442..466

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

                                                                                                                                                                                                                                                          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 (isTrue(oldVnode.isAsyncPlaceholder)) {
      if (isDef(vnode.asyncFactory.resolved)) {
        hydrate(oldVnode.elm, vnode, insertedVnodeQueue);
      } else {
        vnode.isAsyncPlaceholder = true;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 520..527

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function initEvents (vm) {
  vm._events = Object.create(null);
  vm._hasHookEvent = false;
  // init parent attached events
  var listeners = vm.$options._parentListeners;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 12..20

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

                                                                                                                                                                                                                                                          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 (startState) {
    if (typeof el.setStyles === 'function') {
      el.setStyles(startState);
    } else {
      for (var key in startState) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 121..129

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function callActivatedHooks (queue) {
  for (var i = 0; i < queue.length; i++) {
    queue[i]._inactive = true;
    activateChildComponent(queue[i], true /* true */);
  }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/observer/scheduler.js on lines 152..157

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 67.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function createOnceHandler (event, fn) {
  var _target = target;
  return function onceHandler () {
    var res = fn.apply(null, arguments);
    if (res !== null) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 32..40
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7859..7867
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7609..7617

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 66.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function styleValue (value, type) {
  if (type === 'String') {
    return ("\"" + value + "\"")
  } else if (type === 'Number') {
    return ("" + (Number(value)))
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1961..1969
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1963..1971

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 66.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (options && options._isComponent) {
      // optimize internal component instantiation
      // since dynamic options merging is pretty slow, and none of the
      // internal component options needs special treatment.
      initInternalComponent(vm, options);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-vue-framework/factory.js on lines 3147..3158
                                                                                                                                                                                                                                                          src/core/instance/init.js on lines 32..43
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/recycle-list/virtual-component.js on lines 29..40

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            if (options && options._isComponent) {
    // optimize internal component instantiation
    // since dynamic options merging is pretty slow, and none of the
    // internal component options needs special treatment.
    initInternalComponent(vm, options);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 3 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-vue-framework/factory.js on lines 5173..5184
                                                                                                                                                                                                                                                          src/core/instance/init.js on lines 32..43
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/recycle-list/virtual-component.js on lines 29..40

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          var createEmptyVNode = function (text) {
  if ( text === void 0 ) text = '';

  var node = new VNode();
  node.text = text;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 574..581
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 576..583

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function remove (arr, item) {
  if (arr.length) {
    var index = arr.indexOf(item);
    if (index > -1) {
      return arr.splice(index, 1)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 97..104
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 135..142
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 137..144
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 141..148
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 98..105

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function looseIndexOf (arr, val) {
  for (var i = 0; i < arr.length; i++) {
    if (looseEqual(arr[i], val)) { return i }
  }
  return -1
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 314..319
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 316..321

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 65.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                prevChildren.forEach(function (c) {
        c.data.transition = transitionData;

        // TODO: record before patch positions
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/transition-group.js on lines 60..70

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 64.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (vm.$vnode && vm.$parent && vm.$vnode === vm.$parent._vnode) {
      vm.$parent.$el = vm.$el;
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/lifecycle.js on lines 83..85

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

                                                                                                                                                                                                                                                          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 (isDef(i = vnode.children)) {
      for (j = 0; j < vnode.children.length; ++j) {
        invokeDestroyHook(vnode.children[j]);
      }
    }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 354..358

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                (
        a.tag === b.tag &&
        a.isComment === b.isComment &&
        isDef(a.data) === isDef(b.data) &&
        sameInputType(a, b)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 39..47

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

                                                                                                                                                                                                                                                          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 (bindObject) {
      if (process.env.NODE_ENV !== 'production' && !isObject(bindObject)) {
        warn(
          'slot v-bind without argument expects an Object',
          this
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/render-helpers/render-slot.js on lines 19..24

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                if (
        process.env.NODE_ENV !== 'production' &&
        targetState[key] == null &&
        (!activeState || activeState[key] == null) &&
        (!endState || endState[key] == null)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 241..253

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function query (el, document) {
  // document is injected by weex factory wrapper
  var placeholder = document.createComment('root');
  placeholder.hasAttribute = placeholder.removeAttribute = noop; // hack for patch
  document.documentElement.appendChild(placeholder);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/util/element.js on lines 46..52

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 62.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function TextNode (text) {
  this.instanceId = '';
  this.nodeId = latestNodeId++;
  this.parentNode = null;
  this.nodeType = 3;
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/text-node.js on lines 3..9

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                          Watcher.prototype.update = function update () {
  /* istanbul ignore else */
  if (this.lazy) {
    this.dirty = true;
  } else if (this.sync) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 165..174

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                            if (process.env.NODE_ENV !== 'production' && warnMissing && !res) {
    warn(
      'Failed to resolve ' + type.slice(0, -1) + ': ' + id,
      options
    );
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/util/options.js on lines 461..466

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            callbacks.push(function () {
    if (cb) {
      try {
        cb.call(ctx);
      } catch (e) {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/util/next-tick.js on lines 89..99

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function mergeHook$1 (f1, f2) {
  var merged = function (a, b) {
    // flow complains about extra args which is why we use any
    f1(a, b);
    f2(a, b);
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 8478..8486
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 8228..8236

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            if (activeState) {
    for (var key$1 in activeState) {
      if (key$1.indexOf('transition') !== 0) {
        targetState[key$1] = activeState[key$1];
      }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 258..264

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (
      oldChild &&
      oldChild.data &&
      !isSameChild(child, oldChild) &&
      !isAsyncPlaceholder(oldChild) &&
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 164..194

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 59.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function assertObjectType (name, value, vm) {
  if (!isPlainObject(value)) {
    warn(
      "Invalid value for option \"" + name + "\": expected an Object, " +
      "but got " + (toRawType(value)) + ".",
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1656..1664
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1658..1666

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

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                                  if (c.key != null && String(c.key).indexOf('__vlist') !== 0) {
          children.push(c);
          map[c.key] = c
          ;(c.data || (c.data = {})).transition = transitionData;
        } else if (process.env.NODE_ENV !== 'production') {
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition-group.js on lines 65..73
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/transition-group.js on lines 43..53

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

                                                                                                                                                                                                                                                          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 (process.env.NODE_ENV !== 'production' &&
      mode && mode !== 'in-out' && mode !== 'out-in'
    ) {
      warn(
        'invalid <transition> mode: ' + mode,
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 113..120

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                                } else if (isDef(ch)) {
        if (process.env.NODE_ENV !== 'production') {
          checkDuplicateKeys(ch);
        }
        if (isDef(oldVnode.text)) { nodeOps.setTextContent(elm, ''); }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 557..567

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function initProvide (vm) {
  var provide = vm.$options.provide;
  if (provide) {
    vm._provided = typeof provide === 'function'
      ? provide.call(vm)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/inject.js on lines 7..14

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function isKeyNotMatch (expect, actual) {
  if (Array.isArray(expect)) {
    return expect.indexOf(actual) === -1
  } else {
    return expect !== actual
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7307..7313
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7057..7063

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function isValidArrayIndex (val) {
  var n = parseFloat(String(val));
  return n >= 0 && Math.floor(n) === n && isFinite(val)
}
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 71..74
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 73..76

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                          var isHTMLTag = makeMap(
  'html,body,base,head,link,meta,style,title,' +
  'address,article,aside,footer,header,h1,h2,h3,h4,h5,h6,hgroup,nav,section,' +
  'div,dd,dl,dt,figcaption,figure,picture,hr,img,li,main,ol,p,pre,ul,' +
  'a,b,abbr,bdi,bdo,br,cite,code,data,dfn,em,i,kbd,mark,q,rp,rt,rtc,ruby,' +
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 1 hr to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 2170..2182
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 2172..2184

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          function Vue (options) {
  if (process.env.NODE_ENV !== 'production' &&
    !(this instanceof Vue)
  ) {
    warn('Vue is a constructor and should be called with the `new` keyword');
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/index.js on lines 8..15

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            function createRmCb (childElm, listeners) {
    function remove$$1 () {
      if (--remove$$1.listeners === 0) {
        removeNode(childElm);
      }
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 89..97

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            oldClassList.forEach(function (name) {
    var style = stylesheet[name];
    for (var key in style) {
      if (!result.hasOwnProperty(key)) {
        result[key] = '';
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/class.js on lines 62..69

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            for (name in oldStyle) {
    if (!style[name]) {
      supportBatchUpdate
        ? (batchedStyles[normalize(name)] = '')
        : elm.setStyle(normalize(name), '');
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/style.js on lines 53..59

                                                                                                                                                                                                                                                          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

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

                                                                                                                                                                                                                                                              while (i--) {
      cb = cbs[i];
      if (cb === fn || cb.fn === fn) {
        cbs.splice(i, 1);
        break
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 1 hr to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 108..114

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

                                                                                                                                                                                                                                                          function isPrimitive (value) {
  return (
    typeof value === 'string' ||
    typeof value === 'number' ||
    // $flow-disable-line
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 22..30
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 32..40
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 34..42
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 66..74
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 23..31

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          var camelize = cached(function (str) {
  return str.replace(camelizeRE, function (_, c) { return c ? c.toUpperCase() : ''; })
});
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 55 mins to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 129..131
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 167..169
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 169..171
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 173..175
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 130..132

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

                                                                                                                                                                                                                                                            for (name in style) {
    cur = style[name];
    supportBatchUpdate
      ? (batchedStyles[normalize(name)] = cur)
      : elm.setStyle(normalize(name), cur);
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/style.js on lines 60..65

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                              if (child.data.directives && child.data.directives.some(isVShowDirective)) {
      child.data.show = true;
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 55 mins to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 160..162

                                                                                                                                                                                                                                                          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 cb = el._enterCb = once(function () {
    if (cb.cancelled) {
      enterCancelledHook && enterCancelledHook(el);
    } else {
      afterEnterHook && afterEnterHook(el);
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/transition.js on lines 81..88

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function normalizeChildren (children) {
  return isPrimitive(children)
    ? [createTextVNode(children)]
    : Array.isArray(children)
      ? normalizeArrayChildren(children)
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 6672..6678
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 6422..6428

                                                                                                                                                                                                                                                          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 isAllowed = allowedGlobals(key) ||
        (typeof key === 'string' && key.charAt(0) === '_' && !(key in target.$data));
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/proxy.js on lines 58..59

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                                  if (this.max && keys.length > parseInt(this.max)) {
          pruneCacheEntry(cache, keys[0], keys, this._vnode);
        }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/components/keep-alive.js on lines 81..83

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

                                                                                                                                                                                                                                                          var capitalize = cached(function (str) {
  return str.charAt(0).toUpperCase() + str.slice(1)
});
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 50 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 174..176
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 176..178

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            if (!isPlainObject(data)) {
    data = {};
    process.env.NODE_ENV !== 'production' && warn(
      'data functions should return an object:\n' +
      'https://v2.vuejs.org/v2/guide/components.html#data-Must-Be-a-Function',
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/state.js on lines 118..125

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 51.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (isDef(data) && isDef(i = data.hook) && isDef(i = i.prepatch)) {
      i(oldVnode, vnode);
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 544..546

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            function removeNode (el) {
    var parent = nodeOps.parentNode(el);
    // element may have already been removed due to v-html / v-text
    if (isDef(parent)) {
      nodeOps.removeChild(parent, el);
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 99..105

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            if (target._isVue || (ob && ob.vmCount)) {
    process.env.NODE_ENV !== 'production' && warn(
      'Avoid deleting properties on a Vue instance or its root $data ' +
      '- just set it to null.'
    );
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 50 mins to fix
                                                                                                                                                                                                                                                          src/core/observer/index.js on lines 247..253

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                            if (!data.staticClass &&
    !data.class &&
    (!oldData || (!oldData.staticClass && !oldData.class))
  ) {
    return
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/class.js on lines 11..16

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                            render: function render (h) {
    return h('weex:richtext', {
      on: this._events,
      attrs: {
        value: convertVNodeChildren(this.$options._renderChildren || [])
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 45 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/richtext.js on lines 74..81

                                                                                                                                                                                                                                                          Duplicated Code

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

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

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

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 50.

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                              if (process.env.NODE_ENV !== 'production' && children.length > 1) {
      warn(
        '<transition> can only be used on a single element. Use ' +
        '<transition-group> for lists.',
        this.$parent
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 102..108

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

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

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

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

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

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

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

                                                                                                                                                                                                                                                          function initComputed$1 (Comp) {
  var computed = Comp.options.computed;
  for (var key in computed) {
    defineComputed(Comp.prototype, key, computed[key]);
  }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/core/global-api/extend.js on lines 90..95

                                                                                                                                                                                                                                                          Duplicated Code

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

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 49.

                                                                                                                                                                                                                                                          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 6 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          Dep.prototype.depend = function depend () {
  if (Dep.target) {
    Dep.target.addDep(this);
  }
};
                                                                                                                                                                                                                                                          Severity: Major
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 5 other locations - About 40 mins to fix
                                                                                                                                                                                                                                                          packages/weex-template-compiler/build.js on lines 2657..2661
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 1004..1008
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 1006..1010
                                                                                                                                                                                                                                                          packages/vue-template-compiler/browser.js on lines 1049..1053
                                                                                                                                                                                                                                                          packages/vue-template-compiler/build.js on lines 1007..1011

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            if (process.env.NODE_ENV !== 'production' &&
    isDef(data) && isDef(data.key) && !isPrimitive(data.key)
  ) {
    if (!('@binding' in data.key)) {
      warn(
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/create-element.js on lines 71..81

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              if (isDef(vnode.elm) && isDef(ownerArray)) {
      // This vnode was used in a previous render!
      // now it's used as a new node, overwriting its elm would cause
      // potential patch errors down the road when it's used as an insertion
      // reference node. Instead, we clone the node on-demand before creating
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 134..141

                                                                                                                                                                                                                                                          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 (!isCreate) {
    for (key in oldDirs) {
      if (!newDirs[key]) {
        // no longer present, unbind
        callHook$1(oldDirs[key], 'unbind', oldVnode, oldVnode, isDestroy);
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/modules/directives.js on lines 72..79

                                                                                                                                                                                                                                                          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 (
        // not included
        (include && (!name || !matches(include, name))) ||
        // excluded
        (exclude && name && matches(exclude, name))
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 40 mins to fix
                                                                                                                                                                                                                                                          src/core/components/keep-alive.js on lines 122..129

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            beforeUpdate: function beforeUpdate () {
    // force removing pass
    this.__patch__(
      this._vnode,
      this.kept,
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/transition-group.js on lines 78..87

                                                                                                                                                                                                                                                          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 47.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              for (var i$1 = 0; i$1 < cbs.create.length; ++i$1) {
      cbs.create[i$1](emptyNode, vnode);
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 305..307

                                                                                                                                                                                                                                                          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 47.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Similar blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                for (var i = 0, l = cbs.length; i < l; i++) {
        invokeWithErrorHandling(cbs[i], vm, args, vm, info);
      }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/events.js on lines 137..139

                                                                                                                                                                                                                                                          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 47.

                                                                                                                                                                                                                                                          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 callInsert = function () {
      for (var i = 0; i < dirsWithInsert.length; i++) {
        callHook$1(dirsWithInsert[i], 'inserted', vnode, oldVnode);
      }
    };
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          packages/weex-vue-framework/factory.js on lines 6677..6681

                                                                                                                                                                                                                                                          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 47.

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                              mergeVNodeHook(vnode, 'postpatch', function () {
      for (var i = 0; i < dirsWithPostpatch.length; i++) {
        callHook$1(dirsWithPostpatch[i], 'componentUpdated', vnode, oldVnode);
      }
    });
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          packages/weex-vue-framework/factory.js on lines 6664..6668

                                                                                                                                                                                                                                                          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 47.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function markStaticNode (node, key, isOnce) {
  node.isStatic = true;
  node.key = key;
  node.isOnce = isOnce;
}
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7449..7453
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7199..7203

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            function addVnodes (parentElm, refElm, vnodes, startIdx, endIdx, insertedVnodeQueue) {
    for (; startIdx <= endIdx; ++startIdx) {
      createElm(vnodes[startIdx], insertedVnodeQueue, parentElm, refElm, false, vnodes, startIdx);
    }
  }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 341..345

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            update: function update (oldVnode, vnode) {
    if (oldVnode.data.ref !== vnode.data.ref) {
      registerRef(oldVnode, true);
      registerRef(vnode);
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/modules/ref.js on lines 9..14

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            function isPatchable (vnode) {
    while (vnode.componentInstance) {
      vnode = vnode.componentInstance._vnode;
    }
    return isDef(vnode.tag)
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/vdom/patch.js on lines 297..302

                                                                                                                                                                                                                                                          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 (process.env.NODE_ENV !== 'production') {
    defineReactive$$1(vm, '$attrs', parentData && parentData.attrs || emptyObject, function () {
      !isUpdatingChildComponent && warn("$attrs is readonly.", vm);
    }, true);
    defineReactive$$1(vm, '$listeners', options._parentListeners || emptyObject, function () {
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/render.js on lines 41..51

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                                if (cache[key]) {
        vnode.componentInstance = cache[key].componentInstance;
        // make current key freshest
        remove(keys, key);
        keys.push(key);
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/components/keep-alive.js on lines 137..146

                                                                                                                                                                                                                                                          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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function isPromise (val) {
  return (
    isDef(val) &&
    typeof val.then === 'function' &&
    typeof val.catch === 'function'
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 35 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 76..82
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 78..84

                                                                                                                                                                                                                                                          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

                                                                                                                                                                                                                                                          Watcher.prototype.depend = function depend () {
  var i = this.deps.length;
  while (i--) {
    this.deps[i].depend();
  }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 35 mins to fix
                                                                                                                                                                                                                                                          src/core/observer/watcher.js on lines 216..221

                                                                                                                                                                                                                                                          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 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function extend (to, _from) {
  for (var key in _from) {
    to[key] = _from[key];
  }
  return to
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 220..225
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 222..227

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Similar blocks of code found in 3 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function isInInactiveTree (vm) {
  while (vm && (vm = vm.$parent)) {
    if (vm._inactive) { return true }
  }
  return false
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 2 other locations - About 30 mins to fix
                                                                                                                                                                                                                                                          packages/vue-server-renderer/basic.js on lines 7957..7962
                                                                                                                                                                                                                                                          packages/vue-server-renderer/build.dev.js on lines 7707..7712

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              if (parent && !parent._isBeingDestroyed && !vm.$options.abstract) {
      remove(parent.$children, vm);
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/lifecycle.js on lines 106..108

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function isSimpleSpan (vnode) {
  return vnode.children &&
    vnode.children.length === 1 &&
    !vnode.children[0].tag
}
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/components/richtext.js on lines 10..14

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            } else if (isObject(dataClass)) {
    classList.push.apply(classList, Object.keys(dataClass).filter(function (className) { return dataClass[className]; }));
  } else if (typeof dataClass === 'string') {
    classList.push.apply(classList, dataClass.trim().split(/\s+/));
  }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/platforms/weex/runtime/modules/class.js on lines 45..49

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                              if (process.env.NODE_ENV !== 'production') {
      initProxy(vm);
    } else {
      vm._renderProxy = vm;
    }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/core/instance/init.js on lines 45..49

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                          function placeholder (h, rawChild) {
  if (/\d-keep-alive$/.test(rawChild.tag)) {
    return h('keep-alive', {
      props: rawChild.componentOptions.propsData
    })
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 59..65

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          Identical blocks of code found in 2 locations. Consider refactoring.
                                                                                                                                                                                                                                                          Open

                                                                                                                                                                                                                                                            if (compOptions && compOptions.Ctor.options.abstract) {
    return getRealChild(getFirstComponentChild(compOptions.children))
  } else {
    return vnode
  }
                                                                                                                                                                                                                                                          Severity: Minor
                                                                                                                                                                                                                                                          Found in packages/weex-vue-framework/factory.js and 1 other location - About 30 mins to fix
                                                                                                                                                                                                                                                          src/platforms/web/runtime/components/transition.js on lines 36..40

                                                                                                                                                                                                                                                          Duplicated Code

                                                                                                                                                                                                                                                          Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

                                                                                                                                                                                                                                                          Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

                                                                                                                                                                                                                                                          When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

                                                                                                                                                                                                                                                          Tuning

                                                                                                                                                                                                                                                          This issue has a mass of 45.

                                                                                                                                                                                                                                                          We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

                                                                                                                                                                                                                                                          The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

                                                                                                                                                                                                                                                          If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

                                                                                                                                                                                                                                                          See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

                                                                                                                                                                                                                                                          Refactorings

                                                                                                                                                                                                                                                          Further Reading

                                                                                                                                                                                                                                                          There are no issues that match your filters.

                                                                                                                                                                                                                                                          Category
                                                                                                                                                                                                                                                          Status