fluentd-ui 0.3.8 → 0.3.9

data/vendor/assets/javascripts/bower/vue/src/compiler/transclude.js

@@ -0,0 +1,163 @@
+var _ = require('../util')
+var templateParser = require('../parsers/template')
+
+/**
+ * Process an element or a DocumentFragment based on a
+ * instance option object. This allows us to transclude
+ * a template node/fragment before the instance is created,
+ * so the processed fragment can then be cloned and reused
+ * in v-repeat.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Element|DocumentFragment}
+ */
+
+module.exports = function transclude (el, options) {
+  // for template tags, what we want is its content as
+  // a documentFragment (for block instances)
+  if (el.tagName === 'TEMPLATE') {
+    el = templateParser.parse(el)
+  }
+  if (options && options.template) {
+    el = transcludeTemplate(el, options)
+  }
+  if (el instanceof DocumentFragment) {
+    _.prepend(document.createComment('v-start'), el)
+    el.appendChild(document.createComment('v-end'))
+  }
+  return el
+}
+
+/**
+ * Process the template option.
+ * If the replace option is true this will swap the $el.
+ *
+ * @param {Element} el
+ * @param {Object} options
+ * @return {Element|DocumentFragment}
+ */
+
+function transcludeTemplate (el, options) {
+  var template = options.template
+  var frag = templateParser.parse(template, true)
+  if (!frag) {
+    _.warn('Invalid template option: ' + template)
+  } else {
+    collectRawContent(el)
+    if (options.replace) {
+      if (frag.childNodes.length > 1) {
+        transcludeContent(frag)
+        return frag
+      } else {
+        var replacer = frag.firstChild
+        _.copyAttributes(el, replacer)
+        transcludeContent(replacer)
+        return replacer
+      }
+    } else {
+      el.appendChild(frag)
+      transcludeContent(el)
+      return el
+    }
+  }
+}
+
+/**
+ * Collect raw content inside $el before they are
+ * replaced by template content.
+ */
+
+var rawContent
+function collectRawContent (el) {
+  var child
+  rawContent = null
+  if (el.hasChildNodes()) {
+    rawContent = document.createElement('div')
+    /* jshint boss:true */
+    while (child = el.firstChild) {
+      rawContent.appendChild(child)
+    }
+  }
+}
+
+/**
+ * Resolve <content> insertion points mimicking the behavior
+ * of the Shadow DOM spec:
+ *
+ *   http://w3c.github.io/webcomponents/spec/shadow/#insertion-points
+ *
+ * @param {Element|DocumentFragment} el
+ */
+
+function transcludeContent (el) {
+  var outlets = getOutlets(el)
+  var i = outlets.length
+  if (!i) return
+  var outlet, select, selected, j, main
+  // first pass, collect corresponding content
+  // for each outlet.
+  while (i--) {
+    outlet = outlets[i]
+    if (rawContent) {
+      select = outlet.getAttribute('select')
+      if (select) {  // select content
+        selected = rawContent.querySelectorAll(select)
+        outlet.content = _.toArray(
+          selected.length
+            ? selected
+            : outlet.childNodes
+        )
+      } else { // default content
+        main = outlet
+      }
+    } else { // fallback content
+      outlet.content = _.toArray(outlet.childNodes)
+    }
+  }
+  // second pass, actually insert the contents
+  for (i = 0, j = outlets.length; i < j; i++) {
+    outlet = outlets[i]
+    if (outlet !== main) {
+      insertContentAt(outlet, outlet.content)
+    }
+  }
+  // finally insert the main content
+  if (main) {
+    insertContentAt(main, _.toArray(rawContent.childNodes))
+  }
+}
+
+/**
+ * Get <content> outlets from the element/list
+ *
+ * @param {Element|Array} el
+ * @return {Array}
+ */
+
+var concat = [].concat
+function getOutlets (el) {
+  return _.isArray(el)
+    ? concat.apply([], el.map(getOutlets))
+    : el.querySelectorAll
+      ? _.toArray(el.querySelectorAll('content'))
+      : []
+}
+
+/**
+ * Insert an array of nodes at outlet,
+ * then remove the outlet.
+ *
+ * @param {Element} outlet
+ * @param {Array} contents
+ */
+
+function insertContentAt (outlet, contents) {
+  // not using util DOM methods here because
+  // parentNode can be cached
+  var parent = outlet.parentNode
+  for (var i = 0, j = contents.length; i < j; i++) {
+    parent.insertBefore(contents[i], outlet)
+  }
+  parent.removeChild(outlet)
+}

data/vendor/assets/javascripts/bower/vue/src/config.js

@@ -1,19 +1,79 @@
-var TextParser = require('./text-parser')
-
 module.exports = {
-    prefix         : 'v',
-    debug          : false,
-    silent         : false,
-    enterClass     : 'v-enter',
-    leaveClass     : 'v-leave',
-    interpolate    : true
+
+  /**
+   * The prefix to look for when parsing directives.
+   *
+   * @type {String}
+   */
+
+  prefix: 'v-',
+
+  /**
+   * Whether to print debug messages.
+   * Also enables stack trace for warnings.
+   *
+   * @type {Boolean}
+   */
+
+  debug: false,
+
+  /**
+   * Whether to suppress warnings.
+   *
+   * @type {Boolean}
+   */
+
+  silent: false,
+
+  /**
+   * Whether allow observer to alter data objects'
+   * __proto__.
+   *
+   * @type {Boolean}
+   */
+
+  proto: true,
+
+  /**
+   * Whether to parse mustache tags in templates.
+   *
+   * @type {Boolean}
+   */
+
+  interpolate: true,
+
+  /**
+   * Whether to use async rendering.
+   */
+
+  async: true,
+
+  /**
+   * Internal flag to indicate the delimiters have been
+   * changed.
+   *
+   * @type {Boolean}
+   */
+
+  _delimitersChanged: true
+
 }
 
+/**
+ * Interpolation delimiters.
+ * We need to mark the changed flag so that the text parser
+ * knows it needs to recompile the regex.
+ *
+ * @type {Array<String>}
+ */
+
+var delimiters = ['{{', '}}']
 Object.defineProperty(module.exports, 'delimiters', {
-    get: function () {
-        return TextParser.delimiters
-    },
-    set: function (delimiters) {
-        TextParser.setDelimiters(delimiters)
-    }
+  get: function () {
+    return delimiters
+  },
+  set: function (val) {
+    delimiters = val
+    this._delimitersChanged = true
+  }
 })

data/vendor/assets/javascripts/bower/vue/src/directive.js

@@ -1,258 +1,218 @@
-var dirId           = 1,
-    ARG_RE          = /^[\w\$-]+$/,
-    FILTER_TOKEN_RE = /[^\s'"]+|'[^']+'|"[^"]+"/g,
-    NESTING_RE      = /^\$(parent|root)\./,
-    SINGLE_VAR_RE   = /^[\w\.$]+$/,
-    QUOTE_RE        = /"/g,
-    TextParser      = require('./text-parser')
+var _ = require('./util')
+var config = require('./config')
+var Watcher = require('./watcher')
+var textParser = require('./parsers/text')
+var expParser = require('./parsers/expression')
 
 /**
- *  Directive class
- *  represents a single directive instance in the DOM
+ * A directive links a DOM element with a piece of data,
+ * which is the result of evaluating an expression.
+ * It registers a watcher with the expression and calls
+ * the DOM update function when a change is triggered.
+ *
+ * @param {String} name
+ * @param {Node} el
+ * @param {Vue} vm
+ * @param {Object} descriptor
+ *                 - {String} expression
+ *                 - {String} [arg]
+ *                 - {Array<Object>} [filters]
+ * @param {Object} def - directive definition object
+ * @param {Function} [linker] - pre-compiled linker function
+ * @constructor
  */
-function Directive (name, ast, definition, compiler, el) {
 
-    this.id             = dirId++
-    this.name           = name
-    this.compiler       = compiler
-    this.vm             = compiler.vm
-    this.el             = el
-    this.computeFilters = false
-    this.key            = ast.key
-    this.arg            = ast.arg
-    this.expression     = ast.expression
+function Directive (name, el, vm, descriptor, def, linker) {
+  // public
+  this.name = name
+  this.el = el
+  this.vm = vm
+  // copy descriptor props
+  this.raw = descriptor.raw
+  this.expression = descriptor.expression
+  this.arg = descriptor.arg
+  this.filters = _.resolveFilters(vm, descriptor.filters)
+  // private
+  this._linker = linker
+  this._locked = false
+  this._bound = false
+  // init
+  this._bind(def)
+}
 
-    var isEmpty = this.expression === ''
+var p = Directive.prototype
 
-    // mix in properties from the directive definition
-    if (typeof definition === 'function') {
-        this[isEmpty ? 'bind' : 'update'] = definition
-    } else {
-        for (var prop in definition) {
-            this[prop] = definition[prop]
-        }
-    }
-
-    // empty expression, we're done.
-    if (isEmpty || this.isEmpty) {
-        this.isEmpty = true
-        return
-    }
-
-    if (TextParser.Regex.test(this.key)) {
-        this.key = compiler.eval(this.key)
-        if (this.isLiteral) {
-            this.expression = this.key
-        }
-    }
+/**
+ * Initialize the directive, mixin definition properties,
+ * setup the watcher, call definition bind() and update()
+ * if present.
+ *
+ * @param {Object} def
+ */
 
-    var filters = ast.filters,
-        filter, fn, i, l, computed
-    if (filters) {
-        this.filters = []
-        for (i = 0, l = filters.length; i < l; i++) {
-            filter = filters[i]
-            fn = this.compiler.getOption('filters', filter.name)
-            if (fn) {
-                filter.apply = fn
-                this.filters.push(filter)
-                if (fn.computed) {
-                    computed = true
-                }
-            }
-        }
+p._bind = function (def) {
+  if (this.name !== 'cloak' && this.el.removeAttribute) {
+    this.el.removeAttribute(config.prefix + this.name)
+  }
+  if (typeof def === 'function') {
+    this.update = def
+  } else {
+    _.extend(this, def)
+  }
+  this._watcherExp = this.expression
+  this._checkDynamicLiteral()
+  if (this.bind) {
+    this.bind()
+  }
+  if (
+    this.update && this._watcherExp &&
+    (!this.isLiteral || this._isDynamicLiteral) &&
+    !this._checkStatement()
+  ) {
+    // use raw expression as identifier because filters
+    // make them different watchers
+    var watcher = this.vm._watchers[this.raw]
+    // wrapped updater for context
+    var dir = this
+    var update = this._update = function (val, oldVal) {
+      if (!dir._locked) {
+        dir.update(val, oldVal)
+      }
     }
-
-    if (!this.filters || !this.filters.length) {
-        this.filters = null
+    if (!watcher) {
+      watcher = this.vm._watchers[this.raw] = new Watcher(
+        this.vm,
+        this._watcherExp,
+        update, // callback
+        this.filters,
+        this.twoWay, // need setter,
+        this.deep
+      )
+    } else {
+      watcher.addCb(update)
     }
-
-    if (computed) {
-        this.computedKey = Directive.inlineFilters(this.key, this.filters)
-        this.filters = null
+    this._watcher = watcher
+    if (this._initValue != null) {
+      watcher.set(this._initValue)
+    } else {
+      this.update(watcher.value)
     }
-
-    this.isExp =
-        computed ||
-        !SINGLE_VAR_RE.test(this.key) ||
-        NESTING_RE.test(this.key)
-
+  }
+  this._bound = true
 }
 
-var DirProto = Directive.prototype
-
 /**
- *  called when a new value is set 
- *  for computed properties, this will only be called once
- *  during initialization.
+ * check if this is a dynamic literal binding.
+ *
+ * e.g. v-component="{{currentView}}"
  */
-DirProto.$update = function (value, init) {
-    if (this.$lock) return
-    if (init || value !== this.value || (value && typeof value === 'object')) {
-        this.value = value
-        if (this.update) {
-            this.update(
-                this.filters && !this.computeFilters
-                    ? this.$applyFilters(value)
-                    : value,
-                init
-            )
-        }
+
+p._checkDynamicLiteral = function () {
+  var expression = this.expression
+  if (expression && this.isLiteral) {
+    var tokens = textParser.parse(expression)
+    if (tokens) {
+      var exp = textParser.tokensToExp(tokens)
+      this.expression = this.vm.$get(exp)
+      this._watcherExp = exp
+      this._isDynamicLiteral = true
     }
+  }
 }
 
 /**
- *  pipe the value through filters
+ * Check if the directive is a function caller
+ * and if the expression is a callable one. If both true,
+ * we wrap up the expression and use it as the event
+ * handler.
+ *
+ * e.g. v-on="click: a++"
+ *
+ * @return {Boolean}
  */
-DirProto.$applyFilters = function (value) {
-    var filtered = value, filter
-    for (var i = 0, l = this.filters.length; i < l; i++) {
-        filter = this.filters[i]
-        filtered = filter.apply.apply(this.vm, [filtered].concat(filter.args))
+
+p._checkStatement = function () {
+  var expression = this.expression
+  if (
+    expression && this.acceptStatement &&
+    !expParser.pathTestRE.test(expression)
+  ) {
+    var fn = expParser.parse(expression).get
+    var vm = this.vm
+    var handler = function () {
+      fn.call(vm, vm)
+    }
+    if (this.filters) {
+      handler = _.applyFilters(
+        handler,
+        this.filters.read,
+        vm
+      )
     }
-    return filtered
+    this.update(handler)
+    return true
+  }
 }
 
 /**
- *  Unbind diretive
+ * Check for an attribute directive param, e.g. lazy
+ *
+ * @param {String} name
+ * @return {String}
  */
-DirProto.$unbind = function () {
-    // this can be called before the el is even assigned...
-    if (!this.el || !this.vm) return
-    if (this.unbind) this.unbind()
-    this.vm = this.el = this.binding = this.compiler = null
-}
 
-// Exposed static methods -----------------------------------------------------
+p._checkParam = function (name) {
+  var param = this.el.getAttribute(name)
+  if (param !== null) {
+    this.el.removeAttribute(name)
+  }
+  return param
+}
 
 /**
- *  Parse a directive string into an Array of
- *  AST-like objects representing directives
+ * Teardown the watcher and call unbind.
  */
-Directive.parse = function (str) {
-
-    var inSingle = false,
-        inDouble = false,
-        curly    = 0,
-        square   = 0,
-        paren    = 0,
-        begin    = 0,
-        argIndex = 0,
-        dirs     = [],
-        dir      = {},
-        lastFilterIndex = 0,
-        arg
-
-    for (var c, i = 0, l = str.length; i < l; i++) {
-        c = str.charAt(i)
-        if (inSingle) {
-            // check single quote
-            if (c === "'") inSingle = !inSingle
-        } else if (inDouble) {
-            // check double quote
-            if (c === '"') inDouble = !inDouble
-        } else if (c === ',' && !paren && !curly && !square) {
-            // reached the end of a directive
-            pushDir()
-            // reset & skip the comma
-            dir = {}
-            begin = argIndex = lastFilterIndex = i + 1
-        } else if (c === ':' && !dir.key && !dir.arg) {
-            // argument
-            arg = str.slice(begin, i).trim()
-            if (ARG_RE.test(arg)) {
-                argIndex = i + 1
-                dir.arg = arg
-            }
-        } else if (c === '|' && str.charAt(i + 1) !== '|' && str.charAt(i - 1) !== '|') {
-            if (dir.key === undefined) {
-                // first filter, end of key
-                lastFilterIndex = i + 1
-                dir.key = str.slice(argIndex, i).trim()
-            } else {
-                // already has filter
-                pushFilter()
-            }
-        } else if (c === '"') {
-            inDouble = true
-        } else if (c === "'") {
-            inSingle = true
-        } else if (c === '(') {
-            paren++
-        } else if (c === ')') {
-            paren--
-        } else if (c === '[') {
-            square++
-        } else if (c === ']') {
-            square--
-        } else if (c === '{') {
-            curly++
-        } else if (c === '}') {
-            curly--
-        }
-    }
-    if (i === 0 || begin !== i) {
-        pushDir()
-    }
 
-    function pushDir () {
-        dir.expression = str.slice(begin, i).trim()
-        if (dir.key === undefined) {
-            dir.key = str.slice(argIndex, i).trim()
-        } else if (lastFilterIndex !== begin) {
-            pushFilter()
-        }
-        if (i === 0 || dir.key) {
-            dirs.push(dir)
-        }
+p._teardown = function () {
+  if (this._bound) {
+    if (this.unbind) {
+      this.unbind()
     }
-
-    function pushFilter () {
-        var exp = str.slice(lastFilterIndex, i).trim(),
-            filter
-        if (exp) {
-            filter = {}
-            var tokens = exp.match(FILTER_TOKEN_RE)
-            filter.name = tokens[0]
-            filter.args = tokens.length > 1 ? tokens.slice(1) : null
-        }
-        if (filter) {
-            (dir.filters = dir.filters || []).push(filter)
-        }
-        lastFilterIndex = i + 1
+    var watcher = this._watcher
+    if (watcher && watcher.active) {
+      watcher.removeCb(this._update)
+      if (!watcher.active) {
+        this.vm._watchers[this.raw] = null
+      }
     }
-
-    return dirs
+    this._bound = false
+    this.vm = this.el = this._watcher = null
+  }
 }
 
 /**
- *  Inline computed filters so they become part
- *  of the expression
+ * Set the corresponding value with the setter.
+ * This should only be used in two-way directives
+ * e.g. v-model.
+ *
+ * @param {*} value
+ * @param {Boolean} lock - prevent wrtie triggering update.
+ * @public
  */
-Directive.inlineFilters = function (key, filters) {
-    var args, filter
-    for (var i = 0, l = filters.length; i < l; i++) {
-        filter = filters[i]
-        args = filter.args
-            ? ',"' + filter.args.map(escapeQuote).join('","') + '"'
-            : ''
-        key = 'this.$compiler.getOption("filters", "' +
-                filter.name +
-            '").call(this,' +
-                key + args +
-            ')'
-    }
-    return key
-}
 
-/**
- *  Convert double quotes to single quotes
- *  so they don't mess up the generated function body
- */
-function escapeQuote (v) {
-    return v.indexOf('"') > -1
-        ? v.replace(QUOTE_RE, '\'')
-        : v
+p.set = function (value, lock) {
+  if (this.twoWay) {
+    if (lock) {
+      this._locked = true
+    }
+    this._watcher.set(value)
+    if (lock) {
+      var self = this
+      _.nextTick(function () {
+        self._locked = false
+      })
+    }
+  }
 }
 
 module.exports = Directive