fluentd-ui 0.3.9 → 0.3.10

data/vendor/assets/javascripts/bower/vue/src/instance/compile.js

@@ -18,15 +18,36 @@ var transclude = require('../compiler/transclude')
 
 exports._compile = function (el) {
   var options = this.$options
-  if (options._linker) {
+  if (options._linkFn) {
     this._initElement(el)
-    options._linker(this, el)
+    options._linkFn(this, el)
   } else {
     var raw = el
-    el = transclude(el, options)
+    if (options._asComponent) {
+      // separate container element and content
+      var content = options._content = _.extractContent(raw)
+      // create two separate linekrs for container and content
+      var containerLinkFn =
+        compile(raw, options, true, true)
+      if (content) {
+        var contentLinkFn =
+          compile(content, options, true, true)
+        // call content linker now, before transclusion
+        this._contentUnlinkFn =
+          contentLinkFn(options._parent, content)
+      }
+      // tranclude, this possibly replaces original
+      el = transclude(el, options)
+      // now call the container linker on the resolved el
+      this._containerUnlinkFn =
+        containerLinkFn(options._parent, el)
+    } else {
+      // simply transclude
+      el = transclude(el, options)
+    }
     this._initElement(el)
-    var linker = compile(el, options)
-    linker(this, el)
+    var linkFn = compile(el, options)
+    linkFn(this, el)
     if (options.replace) {
       _.replace(raw, el)
     }
@@ -61,11 +82,98 @@ exports._initElement = function (el) {
  * @param {Node} node   - target node
  * @param {Object} desc - parsed directive descriptor
  * @param {Object} def  - directive definition object
- * @param {Function} [linker] - pre-compiled linker fn
  */
 
-exports._bindDir = function (name, node, desc, def, linker) {
+exports._bindDir = function (name, node, desc, def) {
   this._directives.push(
-    new Directive(name, node, this, desc, def, linker)
+    new Directive(name, node, this, desc, def)
   )
+}
+
+/**
+ * Teardown an instance, unobserves the data, unbind all the
+ * directives, turn off all the event listeners, etc.
+ *
+ * @param {Boolean} remove - whether to remove the DOM node.
+ * @param {Boolean} deferCleanup - if true, defer cleanup to
+ *                                 be called later
+ */
+
+exports._destroy = function (remove, deferCleanup) {
+  if (this._isBeingDestroyed) {
+    return
+  }
+  this._callHook('beforeDestroy')
+  this._isBeingDestroyed = true
+  var i
+  // remove self from parent. only necessary
+  // if parent is not being destroyed as well.
+  var parent = this.$parent
+  if (parent && !parent._isBeingDestroyed) {
+    i = parent._children.indexOf(this)
+    parent._children.splice(i, 1)
+  }
+  // destroy all children.
+  if (this._children) {
+    i = this._children.length
+    while (i--) {
+      this._children[i].$destroy()
+    }
+  }
+  // teardown parent linkers
+  if (this._containerUnlinkFn) {
+    this._containerUnlinkFn()
+  }
+  if (this._contentUnlinkFn) {
+    this._contentUnlinkFn()
+  }
+  // teardown all directives. this also tearsdown all
+  // directive-owned watchers. intentionally check for
+  // directives array length on every loop since directives
+  // that manages partial compilation can splice ones out
+  for (i = 0; i < this._directives.length; i++) {
+    this._directives[i]._teardown()
+  }
+  // teardown all user watchers.
+  for (i in this._userWatchers) {
+    this._userWatchers[i].teardown()
+  }
+  // remove reference to self on $el
+  if (this.$el) {
+    this.$el.__vue__ = null
+  }
+  // remove DOM element
+  var self = this
+  if (remove && this.$el) {
+    this.$remove(function () {
+      self._cleanup()
+    })
+  } else if (!deferCleanup) {
+    this._cleanup()
+  }
+}
+
+/**
+ * Clean up to ensure garbage collection.
+ * This is called after the leave transition if there
+ * is any.
+ */
+
+exports._cleanup = function () {
+  // remove reference from data ob
+  this._data.__ob__.removeVm(this)
+  this._data =
+  this._watchers =
+  this._userWatchers =
+  this._watcherList =
+  this.$el =
+  this.$parent =
+  this.$root =
+  this._children =
+  this._directives = null
+  // call the last hook...
+  this._isDestroyed = true
+  this._callHook('destroyed')
+  // turn off all instance listeners.
+  this.$off()
 }

data/vendor/assets/javascripts/bower/vue/src/observer/object.js

@@ -14,16 +14,12 @@ _.define(
   objProto,
   '$add',
   function $add (key, val) {
+    if (this.hasOwnProperty(key)) return
     var ob = this.__ob__
-    if (!ob) {
+    if (!ob || _.isReserved(key)) {
       this[key] = val
       return
     }
-    if (_.isReserved(key)) {
-      _.warn('Refused to $add reserved key: ' + key)
-      return
-    }
-    if (this.hasOwnProperty(key)) return
     ob.convert(key, val)
     if (ob.vms) {
       var i = ob.vms.length
@@ -50,17 +46,12 @@ _.define(
   objProto,
   '$delete',
   function $delete (key) {
+    if (!this.hasOwnProperty(key)) return
+    delete this[key]
     var ob = this.__ob__
-    if (!ob) {
-      delete this[key]
-      return
-    }
-    if (_.isReserved(key)) {
-      _.warn('Refused to $add reserved key: ' + key)
+    if (!ob || _.isReserved(key)) {
       return
     }
-    if (!this.hasOwnProperty(key)) return
-    delete this[key]
     if (ob.vms) {
       var i = ob.vms.length
       while (i--) {

data/vendor/assets/javascripts/bower/vue/src/parsers/template.js

@@ -1,6 +1,7 @@
 var _ = require('../util')
 var Cache = require('../cache')
-var templateCache = new Cache(100)
+var templateCache = new Cache(1000)
+var idSelectorCache = new Cache(1000)
 
 var map = {
   _default : [0, '', ''],
@@ -204,10 +205,11 @@ exports.clone = function (node) {
  *    - id selector: '#some-template-id'
  *    - template string: '<div><span>{{msg}}</span></div>'
  * @param {Boolean} clone
+ * @param {Boolean} noSelector
  * @return {DocumentFragment|undefined}
  */
 
-exports.parse = function (template, clone) {
+exports.parse = function (template, clone, noSelector) {
   var node, frag
 
   // if the template is already a document fragment,
@@ -220,15 +222,15 @@ exports.parse = function (template, clone) {
 
   if (typeof template === 'string') {
     // id selector
-    if (template.charAt(0) === '#') {
+    if (!noSelector && template.charAt(0) === '#') {
       // id selector can be cached too
-      frag = templateCache.get(template)
+      frag = idSelectorCache.get(template)
       if (!frag) {
         node = document.getElementById(template.slice(1))
         if (node) {
           frag = nodeToFragment(node)
           // save selector to cache
-          templateCache.put(template, frag)
+          idSelectorCache.put(template, frag)
         }
       }
     } else {

data/vendor/assets/javascripts/bower/vue/src/util/dom.js

@@ -173,4 +173,25 @@ exports.removeClass = function (el, cls) {
     }
     el.setAttribute('class', cur.trim())
   }
+}
+
+/**
+ * Extract raw content inside an element into a temporary
+ * container div
+ *
+ * @param {Element} el
+ * @return {Element}
+ */
+
+exports.extractContent = function (el) {
+  var child
+  var rawContent
+  if (el.hasChildNodes()) {
+    rawContent = document.createElement('div')
+    /* jshint boss:true */
+    while (child = el.firstChild) {
+      rawContent.appendChild(child)
+    }
+  }
+  return rawContent
 }

data/vendor/assets/javascripts/bower/vue/src/util/merge-option.js

@@ -234,25 +234,22 @@ module.exports = function mergeOptions (parent, child, vm) {
   guardComponents(child.components)
   var options = {}
   var key
+  if (child.mixins) {
+    for (var i = 0, l = child.mixins.length; i < l; i++) {
+      parent = mergeOptions(parent, child.mixins[i], vm)
+    }
+  }
   for (key in parent) {
-    merge(parent[key], child[key], key)
+    merge(key)
   }
   for (key in child) {
     if (!(parent.hasOwnProperty(key))) {
-      merge(parent[key], child[key], key)
-    }
-  }
-  var mixins = child.mixins
-  if (mixins) {
-    for (var i = 0, l = mixins.length; i < l; i++) {
-      for (key in mixins[i]) {
-        merge(options[key], mixins[i][key], key)
-      }
+      merge(key)
     }
   }
-  function merge (parentVal, childVal, key) {
+  function merge (key) {
     var strat = strats[key] || defaultStrat
-    options[key] = strat(parentVal, childVal, vm, key)
+    options[key] = strat(parent[key], child[key], vm, key)
   }
   return options
 }