fluentd-ui 0.3.8 → 0.3.9

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

@@ -0,0 +1,90 @@
+var _ = require('../util')
+var arrayProto = Array.prototype
+var arrayMethods = Object.create(arrayProto)
+
+/**
+ * Intercept mutating methods and emit events
+ */
+
+;[
+  'push',
+  'pop',
+  'shift',
+  'unshift',
+  'splice',
+  'sort',
+  'reverse'
+]
+.forEach(function (method) {
+  // cache original method
+  var original = arrayProto[method]
+  _.define(arrayMethods, method, function mutator () {
+    // avoid leaking arguments:
+    // http://jsperf.com/closure-with-arguments
+    var i = arguments.length
+    var args = new Array(i)
+    while (i--) {
+      args[i] = arguments[i]
+    }
+    var result = original.apply(this, args)
+    var ob = this.__ob__
+    var inserted
+    switch (method) {
+      case 'push':
+        inserted = args
+        break
+      case 'unshift':
+        inserted = args
+        break
+      case 'splice':
+        inserted = args.slice(2)
+        break
+    }
+    if (inserted) ob.observeArray(inserted)
+    // notify change
+    ob.notify()
+    return result
+  })
+})
+
+/**
+ * Swap the element at the given index with a new value
+ * and emits corresponding event.
+ *
+ * @param {Number} index
+ * @param {*} val
+ * @return {*} - replaced element
+ */
+
+_.define(
+  arrayProto,
+  '$set',
+  function $set (index, val) {
+    if (index >= this.length) {
+      this.length = index + 1
+    }
+    return this.splice(index, 1, val)[0]
+  }
+)
+
+/**
+ * Convenience method to remove the element at given index.
+ *
+ * @param {Number} index
+ * @param {*} val
+ */
+
+_.define(
+  arrayProto,
+  '$remove',
+  function $remove (index) {
+    if (typeof index !== 'number') {
+      index = this.indexOf(index)
+    }
+    if (index > -1) {
+      return this.splice(index, 1)[0]
+    }
+  }
+)
+
+module.exports = arrayMethods

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

@@ -0,0 +1,50 @@
+var uid = 0
+
+/**
+ * A dep is an observable that can have multiple
+ * directives subscribing to it.
+ *
+ * @constructor
+ */
+
+function Dep () {
+  this.id = ++uid
+  this.subs = []
+}
+
+var p = Dep.prototype
+
+/**
+ * Add a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+p.addSub = function (sub) {
+  this.subs.push(sub)
+}
+
+/**
+ * Remove a directive subscriber.
+ *
+ * @param {Directive} sub
+ */
+
+p.removeSub = function (sub) {
+  if (this.subs.length) {
+    var i = this.subs.indexOf(sub)
+    if (i > -1) this.subs.splice(i, 1)
+  }
+}
+
+/**
+ * Notify all subscribers of a new value.
+ */
+
+p.notify = function () {
+  for (var i = 0, l = this.subs.length; i < l; i++) {
+    this.subs[i].update()
+  }
+}
+
+module.exports = Dep

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

@@ -0,0 +1,235 @@
+var _ = require('../util')
+var config = require('../config')
+var Dep = require('./dep')
+var arrayMethods = require('./array')
+var arrayKeys = Object.getOwnPropertyNames(arrayMethods)
+require('./object')
+
+var uid = 0
+
+/**
+ * Type enums
+ */
+
+var ARRAY  = 0
+var OBJECT = 1
+
+/**
+ * Augment an target Object or Array by intercepting
+ * the prototype chain using __proto__
+ *
+ * @param {Object|Array} target
+ * @param {Object} proto
+ */
+
+function protoAugment (target, src) {
+  target.__proto__ = src
+}
+
+/**
+ * Augment an target Object or Array by defining
+ * hidden properties.
+ *
+ * @param {Object|Array} target
+ * @param {Object} proto
+ */
+
+function copyAugment (target, src, keys) {
+  var i = keys.length
+  var key
+  while (i--) {
+    key = keys[i]
+    _.define(target, key, src[key])
+  }
+}
+
+/**
+ * Observer class that are attached to each observed
+ * object. Once attached, the observer converts target
+ * object's property keys into getter/setters that
+ * collect dependencies and dispatches updates.
+ *
+ * @param {Array|Object} value
+ * @param {Number} type
+ * @constructor
+ */
+
+function Observer (value, type) {
+  this.id = ++uid
+  this.value = value
+  this.active = true
+  this.deps = []
+  _.define(value, '__ob__', this)
+  if (type === ARRAY) {
+    var augment = config.proto && _.hasProto
+      ? protoAugment
+      : copyAugment
+    augment(value, arrayMethods, arrayKeys)
+    this.observeArray(value)
+  } else if (type === OBJECT) {
+    this.walk(value)
+  }
+}
+
+Observer.target = null
+
+var p = Observer.prototype
+
+/**
+ * Attempt to create an observer instance for a value,
+ * returns the new observer if successfully observed,
+ * or the existing observer if the value already has one.
+ *
+ * @param {*} value
+ * @return {Observer|undefined}
+ * @static
+ */
+
+Observer.create = function (value) {
+  if (
+    value &&
+    value.hasOwnProperty('__ob__') &&
+    value.__ob__ instanceof Observer
+  ) {
+    return value.__ob__
+  } else if (_.isArray(value)) {
+    return new Observer(value, ARRAY)
+  } else if (
+    _.isPlainObject(value) &&
+    !value._isVue // avoid Vue instance
+  ) {
+    return new Observer(value, OBJECT)
+  }
+}
+
+/**
+ * Walk through each property and convert them into
+ * getter/setters. This method should only be called when
+ * value type is Object. Properties prefixed with `$` or `_`
+ * and accessor properties are ignored.
+ *
+ * @param {Object} obj
+ */
+
+p.walk = function (obj) {
+  var keys = Object.keys(obj)
+  var i = keys.length
+  var key, prefix
+  while (i--) {
+    key = keys[i]
+    prefix = key.charCodeAt(0)
+    if (prefix !== 0x24 && prefix !== 0x5F) { // skip $ or _
+      this.convert(key, obj[key])
+    }
+  }
+}
+
+/**
+ * Try to carete an observer for a child value,
+ * and if value is array, link dep to the array.
+ *
+ * @param {*} val
+ * @return {Dep|undefined}
+ */
+
+p.observe = function (val) {
+  return Observer.create(val)
+}
+
+/**
+ * Observe a list of Array items.
+ *
+ * @param {Array} items
+ */
+
+p.observeArray = function (items) {
+  var i = items.length
+  while (i--) {
+    this.observe(items[i])
+  }
+}
+
+/**
+ * Convert a property into getter/setter so we can emit
+ * the events when the property is accessed/changed.
+ *
+ * @param {String} key
+ * @param {*} val
+ */
+
+p.convert = function (key, val) {
+  var ob = this
+  var childOb = ob.observe(val)
+  var dep = new Dep()
+  if (childOb) {
+    childOb.deps.push(dep)
+  }
+  Object.defineProperty(ob.value, key, {
+    enumerable: true,
+    configurable: true,
+    get: function () {
+      // Observer.target is a watcher whose getter is
+      // currently being evaluated.
+      if (ob.active && Observer.target) {
+        Observer.target.addDep(dep)
+      }
+      return val
+    },
+    set: function (newVal) {
+      if (newVal === val) return
+      // remove dep from old value
+      var oldChildOb = val && val.__ob__
+      if (oldChildOb) {
+        var oldDeps = oldChildOb.deps
+        oldDeps.splice(oldDeps.indexOf(dep), 1)
+      }
+      val = newVal
+      // add dep to new value
+      var newChildOb = ob.observe(newVal)
+      if (newChildOb) {
+        newChildOb.deps.push(dep)
+      }
+      dep.notify()
+    }
+  })
+}
+
+/**
+ * Notify change on all self deps on an observer.
+ * This is called when a mutable value mutates. e.g.
+ * when an Array's mutating methods are called, or an
+ * Object's $add/$delete are called.
+ */
+
+p.notify = function () {
+  var deps = this.deps
+  for (var i = 0, l = deps.length; i < l; i++) {
+    deps[i].notify()
+  }
+}
+
+/**
+ * Add an owner vm, so that when $add/$delete mutations
+ * happen we can notify owner vms to proxy the keys and
+ * digest the watchers. This is only called when the object
+ * is observed as an instance's root $data.
+ *
+ * @param {Vue} vm
+ */
+
+p.addVm = function (vm) {
+  (this.vms = this.vms || []).push(vm)
+}
+
+/**
+ * Remove an owner vm. This is called when the object is
+ * swapped out as an instance's $data object.
+ *
+ * @param {Vue} vm
+ */
+
+p.removeVm = function (vm) {
+  this.vms.splice(this.vms.indexOf(vm), 1)
+}
+
+module.exports = Observer

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

@@ -0,0 +1,75 @@
+var _ = require('../util')
+var objProto = Object.prototype
+
+/**
+ * Add a new property to an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @param {*} val
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$add',
+  function $add (key, val) {
+    var ob = this.__ob__
+    if (!ob) {
+      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
+      while (i--) {
+        var vm = ob.vms[i]
+        vm._proxy(key)
+        vm._digest()
+      }
+    } else {
+      ob.notify()
+    }
+  }
+)
+
+/**
+ * Deletes a property from an observed object
+ * and emits corresponding event
+ *
+ * @param {String} key
+ * @public
+ */
+
+_.define(
+  objProto,
+  '$delete',
+  function $delete (key) {
+    var ob = this.__ob__
+    if (!ob) {
+      delete this[key]
+      return
+    }
+    if (_.isReserved(key)) {
+      _.warn('Refused to $add reserved key: ' + key)
+      return
+    }
+    if (!this.hasOwnProperty(key)) return
+    delete this[key]
+    if (ob.vms) {
+      var i = ob.vms.length
+      while (i--) {
+        var vm = ob.vms[i]
+        vm._unproxy(key)
+        vm._digest()
+      }
+    } else {
+      ob.notify()
+    }
+  }
+)