fluentd-ui 0.3.8 → 0.3.9

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

@@ -1,65 +0,0 @@
-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/directives/model.js

@@ -1,174 +0,0 @@
-var utils = require('../utils'),
-    isIE9 = navigator.userAgent.indexOf('MSIE 9.0') > 0,
-    filter = [].filter
-
-/**
- *  Returns an array of values from a multiple select
- */
-function getMultipleSelectOptions (select) {
-    return filter
-        .call(select.options, function (option) {
-            return option.selected
-        })
-        .map(function (option) {
-            return option.value || option.text
-        })
-}
-
-/**
- *  Two-way binding for form input elements
- */
-module.exports = {
-
-    bind: function () {
-
-        var self = this,
-            el   = self.el,
-            type = el.type,
-            tag  = el.tagName
-
-        self.lock = false
-        self.ownerVM = self.binding.compiler.vm
-
-        // determine what event to listen to
-        self.event =
-            (self.compiler.options.lazy ||
-            tag === 'SELECT' ||
-            type === 'checkbox' || type === 'radio')
-                ? 'change'
-                : 'input'
-
-        // determine the attribute to change when updating
-        self.attr = type === 'checkbox'
-            ? 'checked'
-            : (tag === 'INPUT' || tag === 'SELECT' || tag === 'TEXTAREA')
-                ? 'value'
-                : 'innerHTML'
-
-        // select[multiple] support
-        if(tag === 'SELECT' && el.hasAttribute('multiple')) {
-            this.multi = true
-        }
-
-        var compositionLock = false
-        self.cLock = function () {
-            compositionLock = true
-        }
-        self.cUnlock = function () {
-            compositionLock = false
-        }
-        el.addEventListener('compositionstart', this.cLock)
-        el.addEventListener('compositionend', this.cUnlock)
-
-        // attach listener
-        self.set = self.filters
-            ? function () {
-                if (compositionLock) return
-                // if this directive has filters
-                // we need to let the vm.$set trigger
-                // update() so filters are applied.
-                // therefore we have to record cursor position
-                // so that after vm.$set changes the input
-                // value we can put the cursor back at where it is
-                var cursorPos
-                try { cursorPos = el.selectionStart } catch (e) {}
-
-                self._set()
-
-                // since updates are async
-                // we need to reset cursor position async too
-                utils.nextTick(function () {
-                    if (cursorPos !== undefined) {
-                        el.setSelectionRange(cursorPos, cursorPos)
-                    }
-                })
-            }
-            : function () {
-                if (compositionLock) return
-                // no filters, don't let it trigger update()
-                self.lock = true
-
-                self._set()
-
-                utils.nextTick(function () {
-                    self.lock = false
-                })
-            }
-        el.addEventListener(self.event, self.set)
-
-        // fix shit for IE9
-        // since it doesn't fire input on backspace / del / cut
-        if (isIE9) {
-            self.onCut = function () {
-                // cut event fires before the value actually changes
-                utils.nextTick(function () {
-                    self.set()
-                })
-            }
-            self.onDel = function (e) {
-                if (e.keyCode === 46 || e.keyCode === 8) {
-                    self.set()
-                }
-            }
-            el.addEventListener('cut', self.onCut)
-            el.addEventListener('keyup', self.onDel)
-        }
-    },
-
-    _set: function () {
-        this.ownerVM.$set(
-            this.key, this.multi
-                ? getMultipleSelectOptions(this.el)
-                : this.el[this.attr]
-        )
-    },
-
-    update: function (value, init) {
-        /* jshint eqeqeq: false */
-        // sync back inline value if initial data is undefined
-        if (init && value === undefined) {
-            return this._set()
-        }
-        if (this.lock) return
-        var el = this.el
-        if (el.tagName === 'SELECT') { // select dropdown
-            el.selectedIndex = -1
-            if(this.multi && Array.isArray(value)) {
-                value.forEach(this.updateSelect, this)
-            } else {
-                this.updateSelect(value)
-            }
-        } else if (el.type === 'radio') { // radio button
-            el.checked = value == el.value
-        } else if (el.type === 'checkbox') { // checkbox
-            el.checked = !!value
-        } else {
-            el[this.attr] = utils.guard(value)
-        }
-    },
-
-    updateSelect: function (value) {
-        /* jshint eqeqeq: false */
-        // setting <select>'s value in IE9 doesn't work
-        // we have to manually loop through the options
-        var options = this.el.options,
-            i = options.length
-        while (i--) {
-            if (options[i].value == value) {
-                options[i].selected = true
-                break
-            }
-        }
-    },
-
-    unbind: function () {
-        var el = this.el
-        el.removeEventListener(this.event, this.set)
-        el.removeEventListener('compositionstart', this.cLock)
-        el.removeEventListener('compositionend', this.cUnlock)
-        if (isIE9) {
-            el.removeEventListener('cut', this.onCut)
-            el.removeEventListener('keyup', this.onDel)
-        }
-    }
-}

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

@@ -1,56 +0,0 @@
-/**
- *  Manages a conditional child VM using the
- *  binding's value as the component ID.
- */
-module.exports = {
-
-    bind: function () {
-
-        // track position in DOM with a ref node
-        var el       = this.raw = this.el,
-            parent   = el.parentNode,
-            ref      = this.ref = document.createComment('v-view')
-        parent.insertBefore(ref, el)
-        parent.removeChild(el)
-
-        // cache original content
-        /* jshint boss: true */
-        var node,
-            frag = this.inner = document.createElement('div')
-        while (node = el.firstChild) {
-            frag.appendChild(node)
-        }
-
-    },
-
-    update: function(value) {
-
-        this.unbind()
-
-        var Ctor  = this.compiler.getOption('components', value)
-        if (!Ctor) return
-
-        this.childVM = new Ctor({
-            el: this.raw.cloneNode(true),
-            parent: this.vm,
-            compilerOptions: {
-                rawContent: this.inner.cloneNode(true)
-            }
-        })
-
-        this.el = this.childVM.$el
-        if (this.compiler.init) {
-            this.ref.parentNode.insertBefore(this.el, this.ref)
-        } else {
-            this.childVM.$before(this.ref)
-        }
-
-    },
-
-    unbind: function() {
-        if (this.childVM) {
-            this.childVM.$destroy()
-        }
-    }
-
-}

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

@@ -1,97 +0,0 @@
-var slice = [].slice
-
-function Emitter (ctx) {
-    this._ctx = ctx || this
-}
-
-var EmitterProto = Emitter.prototype
-
-EmitterProto.on = function (event, fn) {
-    this._cbs = this._cbs || {}
-    ;(this._cbs[event] = this._cbs[event] || [])
-        .push(fn)
-    return this
-}
-
-EmitterProto.once = function (event, fn) {
-    var self = this
-    this._cbs = this._cbs || {}
-
-    function on () {
-        self.off(event, on)
-        fn.apply(this, arguments)
-    }
-
-    on.fn = fn
-    this.on(event, on)
-    return this
-}
-
-EmitterProto.off = function (event, fn) {
-    this._cbs = this._cbs || {}
-
-    // all
-    if (!arguments.length) {
-        this._cbs = {}
-        return this
-    }
-
-    // specific event
-    var callbacks = this._cbs[event]
-    if (!callbacks) return this
-
-    // remove all handlers
-    if (arguments.length === 1) {
-        delete this._cbs[event]
-        return this
-    }
-
-    // remove specific handler
-    var cb
-    for (var i = 0; i < callbacks.length; i++) {
-        cb = callbacks[i]
-        if (cb === fn || cb.fn === fn) {
-            callbacks.splice(i, 1)
-            break
-        }
-    }
-    return this
-}
-
-/**
- *  The internal, faster emit with fixed amount of arguments
- *  using Function.call
- */
-EmitterProto.emit = function (event, a, b, c) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event]
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].call(this._ctx, a, b, c)
-        }
-    }
-
-    return this
-}
-
-/**
- *  The external emit using Function.apply
- */
-EmitterProto.applyEmit = function (event) {
-    this._cbs = this._cbs || {}
-    var callbacks = this._cbs[event], args
-
-    if (callbacks) {
-        callbacks = callbacks.slice(0)
-        args = slice.call(arguments, 1)
-        for (var i = 0, len = callbacks.length; i < len; i++) {
-            callbacks[i].apply(this._ctx, args)
-        }
-    }
-
-    return this
-}
-
-module.exports = Emitter

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

@@ -1,190 +0,0 @@
-var utils           = require('./utils'),
-    STR_SAVE_RE     = /"(?:[^"\\]|\\.)*"|'(?:[^'\\]|\\.)*'/g,
-    STR_RESTORE_RE  = /"(\d+)"/g,
-    NEWLINE_RE      = /\n/g,
-    CTOR_RE         = new RegExp('constructor'.split('').join('[\'"+, ]*')),
-    UNICODE_RE      = /\\u\d\d\d\d/
-
-// Variable extraction scooped from https://github.com/RubyLouvre/avalon
-
-var KEYWORDS =
-        // keywords
-        'break,case,catch,continue,debugger,default,delete,do,else,false' +
-        ',finally,for,function,if,in,instanceof,new,null,return,switch,this' +
-        ',throw,true,try,typeof,var,void,while,with,undefined' +
-        // reserved
-        ',abstract,boolean,byte,char,class,const,double,enum,export,extends' +
-        ',final,float,goto,implements,import,int,interface,long,native' +
-        ',package,private,protected,public,short,static,super,synchronized' +
-        ',throws,transient,volatile' +
-        // ECMA 5 - use strict
-        ',arguments,let,yield' +
-        // allow using Math in expressions
-        ',Math',
-        
-    KEYWORDS_RE = new RegExp(["\\b" + KEYWORDS.replace(/,/g, '\\b|\\b') + "\\b"].join('|'), 'g'),
-    REMOVE_RE   = /\/\*(?:.|\n)*?\*\/|\/\/[^\n]*\n|\/\/[^\n]*$|'[^']*'|"[^"]*"|[\s\t\n]*\.[\s\t\n]*[$\w\.]+|[\{,]\s*[\w\$_]+\s*:/g,
-    SPLIT_RE    = /[^\w$]+/g,
-    NUMBER_RE   = /\b\d[^,]*/g,
-    BOUNDARY_RE = /^,+|,+$/g
-
-/**
- *  Strip top level variable names from a snippet of JS expression
- */
-function getVariables (code) {
-    code = code
-        .replace(REMOVE_RE, '')
-        .replace(SPLIT_RE, ',')
-        .replace(KEYWORDS_RE, '')
-        .replace(NUMBER_RE, '')
-        .replace(BOUNDARY_RE, '')
-    return code
-        ? code.split(/,+/)
-        : []
-}
-
-/**
- *  A given path could potentially exist not on the
- *  current compiler, but up in the parent chain somewhere.
- *  This function generates an access relationship string
- *  that can be used in the getter function by walking up
- *  the parent chain to check for key existence.
- *
- *  It stops at top parent if no vm in the chain has the
- *  key. It then creates any missing bindings on the
- *  final resolved vm.
- */
-function traceScope (path, compiler, data) {
-    var rel  = '',
-        dist = 0,
-        self = compiler
-
-    if (data && utils.get(data, path) !== undefined) {
-        // hack: temporarily attached data
-        return '$temp.'
-    }
-
-    while (compiler) {
-        if (compiler.hasKey(path)) {
-            break
-        } else {
-            compiler = compiler.parent
-            dist++
-        }
-    }
-    if (compiler) {
-        while (dist--) {
-            rel += '$parent.'
-        }
-        if (!compiler.bindings[path] && path.charAt(0) !== '$') {
-            compiler.createBinding(path)
-        }
-    } else {
-        self.createBinding(path)
-    }
-    return rel
-}
-
-/**
- *  Create a function from a string...
- *  this looks like evil magic but since all variables are limited
- *  to the VM's data it's actually properly sandboxed
- */
-function makeGetter (exp, raw) {
-    var fn
-    try {
-        fn = new Function(exp)
-    } catch (e) {
-        utils.warn('Error parsing expression: ' + raw)
-    }
-    return fn
-}
-
-/**
- *  Escape a leading dollar sign for regex construction
- */
-function escapeDollar (v) {
-    return v.charAt(0) === '$'
-        ? '\\' + v
-        : v
-}
-
-/**
- *  Parse and return an anonymous computed property getter function
- *  from an arbitrary expression, together with a list of paths to be
- *  created as bindings.
- */
-exports.parse = function (exp, compiler, data) {
-    // unicode and 'constructor' are not allowed for XSS security.
-    if (UNICODE_RE.test(exp) || CTOR_RE.test(exp)) {
-        utils.warn('Unsafe expression: ' + exp)
-        return
-    }
-    // extract variable names
-    var vars = getVariables(exp)
-    if (!vars.length) {
-        return makeGetter('return ' + exp, exp)
-    }
-    vars = utils.unique(vars)
-
-    var accessors = '',
-        has       = utils.hash(),
-        strings   = [],
-        // construct a regex to extract all valid variable paths
-        // ones that begin with "$" are particularly tricky
-        // because we can't use \b for them
-        pathRE = new RegExp(
-            "[^$\\w\\.](" +
-            vars.map(escapeDollar).join('|') +
-            ")[$\\w\\.]*\\b", 'g'
-        ),
-        body = (' ' + exp)
-            .replace(STR_SAVE_RE, saveStrings)
-            .replace(pathRE, replacePath)
-            .replace(STR_RESTORE_RE, restoreStrings)
-
-    body = accessors + 'return ' + body
-
-    function saveStrings (str) {
-        var i = strings.length
-        // escape newlines in strings so the expression
-        // can be correctly evaluated
-        strings[i] = str.replace(NEWLINE_RE, '\\n')
-        return '"' + i + '"'
-    }
-
-    function replacePath (path) {
-        // keep track of the first char
-        var c = path.charAt(0)
-        path = path.slice(1)
-        var val = 'this.' + traceScope(path, compiler, data) + path
-        if (!has[path]) {
-            accessors += val + ';'
-            has[path] = 1
-        }
-        // don't forget to put that first char back
-        return c + val
-    }
-
-    function restoreStrings (str, i) {
-        return strings[i]
-    }
-
-    return makeGetter(body, exp)
-}
-
-/**
- *  Evaluate an expression in the context of a compiler.
- *  Accepts additional data.
- */
-exports.eval = function (exp, compiler, data) {
-    var getter = exports.parse(exp, compiler, data), res
-    if (getter) {
-        // hack: temporarily attach the additional data so
-        // it can be accessed in the getter
-        compiler.vm.$temp = data
-        res = getter.call(compiler.vm)
-        delete compiler.vm.$temp
-    }
-    return res
-}