fluentd-ui 0.1.0

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

@@ -0,0 +1,19 @@
+var TextParser = require('./text-parser')
+
+module.exports = {
+    prefix         : 'v',
+    debug          : false,
+    silent         : false,
+    enterClass     : 'v-enter',
+    leaveClass     : 'v-leave',
+    interpolate    : true
+}
+
+Object.defineProperty(module.exports, 'delimiters', {
+    get: function () {
+        return TextParser.delimiters
+    },
+    set: function (delimiters) {
+        TextParser.setDelimiters(delimiters)
+    }
+})

data/vendor/assets/javascripts/bower/vue/src/deps-parser.js

@@ -0,0 +1,65 @@
+var Emitter  = require('./emitter'),
+    utils    = require('./utils'),
+    Observer = require('./observer'),
+    catcher  = new Emitter()
+
+/**
+ *  Auto-extract the dependencies of a computed property
+ *  by recording the getters triggered when evaluating it.
+ */
+function catchDeps (binding) {
+    if (binding.isFn) return
+    utils.log('\n- ' + binding.key)
+    var got = utils.hash()
+    binding.deps = []
+    catcher.on('get', function (dep) {
+        var has = got[dep.key]
+        if (
+            // avoid duplicate bindings
+            (has && has.compiler === dep.compiler) ||
+            // avoid repeated items as dependency
+            // only when the binding is from self or the parent chain
+            (dep.compiler.repeat && !isParentOf(dep.compiler, binding.compiler))
+        ) {
+            return
+        }
+        got[dep.key] = dep
+        utils.log('  - ' + dep.key)
+        binding.deps.push(dep)
+        dep.subs.push(binding)
+    })
+    binding.value.$get()
+    catcher.off('get')
+}
+
+/**
+ *  Test if A is a parent of or equals B
+ */
+function isParentOf (a, b) {
+    while (b) {
+        if (a === b) {
+            return true
+        }
+        b = b.parent
+    }
+}
+
+module.exports = {
+
+    /**
+     *  the observer that catches events triggered by getters
+     */
+    catcher: catcher,
+
+    /**
+     *  parse a list of computed property bindings
+     */
+    parse: function (bindings) {
+        utils.log('\nparsing dependencies...')
+        Observer.shouldGet = true
+        bindings.forEach(catchDeps)
+        Observer.shouldGet = false
+        utils.log('\ndone.')
+    }
+    
+}

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

@@ -0,0 +1,258 @@
+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')
+
+/**
+ *  Directive class
+ *  represents a single directive instance in the DOM
+ */
+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
+
+    var isEmpty = this.expression === ''
+
+    // 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
+        }
+    }
+
+    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
+                }
+            }
+        }
+    }
+
+    if (!this.filters || !this.filters.length) {
+        this.filters = null
+    }
+
+    if (computed) {
+        this.computedKey = Directive.inlineFilters(this.key, this.filters)
+        this.filters = null
+    }
+
+    this.isExp =
+        computed ||
+        !SINGLE_VAR_RE.test(this.key) ||
+        NESTING_RE.test(this.key)
+
+}
+
+var DirProto = Directive.prototype
+
+/**
+ *  called when a new value is set 
+ *  for computed properties, this will only be called once
+ *  during initialization.
+ */
+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
+            )
+        }
+    }
+}
+
+/**
+ *  pipe the value through filters
+ */
+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))
+    }
+    return filtered
+}
+
+/**
+ *  Unbind diretive
+ */
+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 -----------------------------------------------------
+
+/**
+ *  Parse a directive string into an Array of
+ *  AST-like objects representing directives
+ */
+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)
+        }
+    }
+
+    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
+    }
+
+    return dirs
+}
+
+/**
+ *  Inline computed filters so they become part
+ *  of the expression
+ */
+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
+}
+
+module.exports = Directive

data/vendor/assets/javascripts/bower/vue/src/directives/html.js

@@ -0,0 +1,41 @@
+var utils = require('../utils'),
+    slice = [].slice
+
+/**
+ *  Binding for innerHTML
+ */
+module.exports = {
+
+    bind: function () {
+        // a comment node means this is a binding for
+        // {{{ inline unescaped html }}}
+        if (this.el.nodeType === 8) {
+            // hold nodes
+            this.nodes = []
+        }
+    },
+
+    update: function (value) {
+        value = utils.guard(value)
+        if (this.nodes) {
+            this.swap(value)
+        } else {
+            this.el.innerHTML = value
+        }
+    },
+
+    swap: function (value) {
+        var parent = this.el.parentNode,
+            nodes  = this.nodes,
+            i      = nodes.length
+        // remove old nodes
+        while (i--) {
+            parent.removeChild(nodes[i])
+        }
+        // convert new value to a fragment
+        var frag = utils.toFragment(value)
+        // save a reference to these nodes so we can remove later
+        this.nodes = slice.call(frag.childNodes)
+        parent.insertBefore(frag, this.el)
+    }
+}

data/vendor/assets/javascripts/bower/vue/src/directives/if.js

@@ -0,0 +1,56 @@
+var utils    = require('../utils')
+
+/**
+ *  Manages a conditional child VM
+ */
+module.exports = {
+
+    bind: function () {
+        
+        this.parent = this.el.parentNode
+        this.ref    = document.createComment('vue-if')
+        this.Ctor   = this.compiler.resolveComponent(this.el)
+
+        // insert ref
+        this.parent.insertBefore(this.ref, this.el)
+        this.parent.removeChild(this.el)
+
+        if (utils.attr(this.el, 'view')) {
+            utils.warn(
+                'Conflict: v-if cannot be used together with v-view. ' +
+                'Just set v-view\'s binding value to empty string to empty it.'
+            )
+        }
+        if (utils.attr(this.el, 'repeat')) {
+            utils.warn(
+                'Conflict: v-if cannot be used together with v-repeat. ' +
+                'Use `v-show` or the `filterBy` filter instead.'
+            )
+        }
+    },
+
+    update: function (value) {
+
+        if (!value) {
+            this.unbind()
+        } else if (!this.childVM) {
+            this.childVM = new this.Ctor({
+                el: this.el.cloneNode(true),
+                parent: this.vm
+            })
+            if (this.compiler.init) {
+                this.parent.insertBefore(this.childVM.$el, this.ref)
+            } else {
+                this.childVM.$before(this.ref)
+            }
+        }
+        
+    },
+
+    unbind: function () {
+        if (this.childVM) {
+            this.childVM.$destroy()
+            this.childVM = null
+        }
+    }
+}

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

@@ -0,0 +1,129 @@
+var utils      = require('../utils'),
+    config     = require('../config'),
+    transition = require('../transition'),
+    directives = module.exports = utils.hash()
+
+/**
+ *  Nest and manage a Child VM
+ */
+directives.component = {
+    isLiteral: true,
+    bind: function () {
+        if (!this.el.vue_vm) {
+            this.childVM = new this.Ctor({
+                el: this.el,
+                parent: this.vm
+            })
+        }
+    },
+    unbind: function () {
+        if (this.childVM) {
+            this.childVM.$destroy()
+        }
+    }
+}
+
+/**
+ *  Binding HTML attributes
+ */
+directives.attr = {
+    bind: function () {
+        var params = this.vm.$options.paramAttributes
+        this.isParam = params && params.indexOf(this.arg) > -1
+    },
+    update: function (value) {
+        if (value || value === 0) {
+            this.el.setAttribute(this.arg, value)
+        } else {
+            this.el.removeAttribute(this.arg)
+        }
+        if (this.isParam) {
+            this.vm[this.arg] = utils.checkNumber(value)
+        }
+    }
+}
+
+/**
+ *  Binding textContent
+ */
+directives.text = {
+    bind: function () {
+        this.attr = this.el.nodeType === 3
+            ? 'nodeValue'
+            : 'textContent'
+    },
+    update: function (value) {
+        this.el[this.attr] = utils.guard(value)
+    }
+}
+
+/**
+ *  Binding CSS display property
+ */
+directives.show = function (value) {
+    var el = this.el,
+        target = value ? '' : 'none',
+        change = function () {
+            el.style.display = target
+        }
+    transition(el, value ? 1 : -1, change, this.compiler)
+}
+
+/**
+ *  Binding CSS classes
+ */
+directives['class'] = function (value) {
+    if (this.arg) {
+        utils[value ? 'addClass' : 'removeClass'](this.el, this.arg)
+    } else {
+        if (this.lastVal) {
+            utils.removeClass(this.el, this.lastVal)
+        }
+        if (value) {
+            utils.addClass(this.el, value)
+            this.lastVal = value
+        }
+    }
+}
+
+/**
+ *  Only removed after the owner VM is ready
+ */
+directives.cloak = {
+    isEmpty: true,
+    bind: function () {
+        var el = this.el
+        this.compiler.observer.once('hook:ready', function () {
+            el.removeAttribute(config.prefix + '-cloak')
+        })
+    }
+}
+
+/**
+ *  Store a reference to self in parent VM's $
+ */
+directives.ref = {
+    isLiteral: true,
+    bind: function () {
+        var id = this.expression
+        if (id) {
+            this.vm.$parent.$[id] = this.vm
+        }
+    },
+    unbind: function () {
+        var id = this.expression
+        if (id) {
+            delete this.vm.$parent.$[id]
+        }
+    }
+}
+
+directives.on      = require('./on')
+directives.repeat  = require('./repeat')
+directives.model   = require('./model')
+directives['if']   = require('./if')
+directives['with'] = require('./with')
+directives.html    = require('./html')
+directives.style   = require('./style')
+directives.partial = require('./partial')
+directives.view    = require('./view')