fluentd-ui 0.1.0

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

@@ -0,0 +1,40 @@
+var prefixes = ['-webkit-', '-moz-', '-ms-']
+
+/**
+ *  Binding for CSS styles
+ */
+module.exports = {
+
+    bind: function () {
+        var prop = this.arg
+        if (!prop) return
+        if (prop.charAt(0) === '$') {
+            // properties that start with $ will be auto-prefixed
+            prop = prop.slice(1)
+            this.prefixed = true
+        }
+        this.prop = prop
+    },
+
+    update: function (value) {
+        var prop = this.prop
+        if (prop) {
+            var isImportant = value.slice(-10) === '!important'
+                ? 'important'
+                : ''
+            if (isImportant) {
+                value = value.slice(0, -10).trim()
+            }
+            this.el.style.setProperty(prop, value, isImportant)
+            if (this.prefixed) {
+                var i = prefixes.length
+                while (i--) {
+                    this.el.style.setProperty(prefixes[i] + prop, value, isImportant)
+                }
+            }
+        } else {
+            this.el.style.cssText = value
+        }
+    }
+
+}

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

@@ -0,0 +1,56 @@
+/**
+ *  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/directives/with.js

@@ -0,0 +1,50 @@
+var utils = require('../utils')
+
+/**
+ *  Binding for inheriting data from parent VMs.
+ */
+module.exports = {
+
+    bind: function () {
+
+        var self      = this,
+            childKey  = self.arg,
+            parentKey = self.key,
+            compiler  = self.compiler,
+            owner     = self.binding.compiler
+
+        if (compiler === owner) {
+            this.alone = true
+            return
+        }
+
+        if (childKey) {
+            if (!compiler.bindings[childKey]) {
+                compiler.createBinding(childKey)
+            }
+            // sync changes on child back to parent
+            compiler.observer.on('change:' + childKey, function (val) {
+                if (compiler.init) return
+                if (!self.lock) {
+                    self.lock = true
+                    utils.nextTick(function () {
+                        self.lock = false
+                    })
+                }
+                owner.vm.$set(parentKey, val)
+            })
+        }
+    },
+
+    update: function (value) {
+        // sync from parent
+        if (!this.alone && !this.lock) {
+            if (this.arg) {
+                this.vm.$set(this.arg, value)
+            } else if (this.vm.$data !== value) {
+                this.vm.$data = value
+            }
+        }
+    }
+
+}

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

@@ -0,0 +1,97 @@
+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

@@ -0,0 +1,190 @@
+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
+}

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

@@ -0,0 +1,190 @@
+var utils    = require('./utils'),
+    get      = utils.get,
+    slice    = [].slice,
+    QUOTE_RE = /^'.*'$/,
+    filters  = module.exports = utils.hash()
+
+/**
+ *  'abc' => 'Abc'
+ */
+filters.capitalize = function (value) {
+    if (!value && value !== 0) return ''
+    value = value.toString()
+    return value.charAt(0).toUpperCase() + value.slice(1)
+}
+
+/**
+ *  'abc' => 'ABC'
+ */
+filters.uppercase = function (value) {
+    return (value || value === 0)
+        ? value.toString().toUpperCase()
+        : ''
+}
+
+/**
+ *  'AbC' => 'abc'
+ */
+filters.lowercase = function (value) {
+    return (value || value === 0)
+        ? value.toString().toLowerCase()
+        : ''
+}
+
+/**
+ *  12345 => $12,345.00
+ */
+filters.currency = function (value, sign) {
+    if (!value && value !== 0) return ''
+    sign = sign || '$'
+    var s = Math.floor(value).toString(),
+        i = s.length % 3,
+        h = i > 0 ? (s.slice(0, i) + (s.length > 3 ? ',' : '')) : '',
+        f = '.' + value.toFixed(2).slice(-2)
+    return sign + h + s.slice(i).replace(/(\d{3})(?=\d)/g, '$1,') + f
+}
+
+/**
+ *  args: an array of strings corresponding to
+ *  the single, double, triple ... forms of the word to
+ *  be pluralized. When the number to be pluralized
+ *  exceeds the length of the args, it will use the last
+ *  entry in the array.
+ *
+ *  e.g. ['single', 'double', 'triple', 'multiple']
+ */
+filters.pluralize = function (value) {
+    var args = slice.call(arguments, 1)
+    return args.length > 1
+        ? (args[value - 1] || args[args.length - 1])
+        : (args[value - 1] || args[0] + 's')
+}
+
+/**
+ *  A special filter that takes a handler function,
+ *  wraps it so it only gets triggered on specific keypresses.
+ *
+ *  v-on only
+ */
+
+var keyCodes = {
+    enter    : 13,
+    tab      : 9,
+    'delete' : 46,
+    up       : 38,
+    left     : 37,
+    right    : 39,
+    down     : 40,
+    esc      : 27
+}
+
+filters.key = function (handler, key) {
+    if (!handler) return
+    var code = keyCodes[key]
+    if (!code) {
+        code = parseInt(key, 10)
+    }
+    return function (e) {
+        if (e.keyCode === code) {
+            return handler.call(this, e)
+        }
+    }
+}
+
+/**
+ *  Filter filter for v-repeat
+ */
+filters.filterBy = function (arr, searchKey, delimiter, dataKey) {
+
+    // allow optional `in` delimiter
+    // because why not
+    if (delimiter && delimiter !== 'in') {
+        dataKey = delimiter
+    }
+
+    // get the search string
+    var search = stripQuotes(searchKey) || this.$get(searchKey)
+    if (!search) return arr
+    search = search.toLowerCase()
+
+    // get the optional dataKey
+    dataKey = dataKey && (stripQuotes(dataKey) || this.$get(dataKey))
+
+    // convert object to array
+    if (!Array.isArray(arr)) {
+        arr = utils.objectToArray(arr)
+    }
+
+    return arr.filter(function (item) {
+        return dataKey
+            ? contains(get(item, dataKey), search)
+            : contains(item, search)
+    })
+
+}
+
+filters.filterBy.computed = true
+
+/**
+ *  Sort fitler for v-repeat
+ */
+filters.orderBy = function (arr, sortKey, reverseKey) {
+
+    var key = stripQuotes(sortKey) || this.$get(sortKey)
+    if (!key) return arr
+
+    // convert object to array
+    if (!Array.isArray(arr)) {
+        arr = utils.objectToArray(arr)
+    }
+
+    var order = 1
+    if (reverseKey) {
+        if (reverseKey === '-1') {
+            order = -1
+        } else if (reverseKey.charAt(0) === '!') {
+            reverseKey = reverseKey.slice(1)
+            order = this.$get(reverseKey) ? 1 : -1
+        } else {
+            order = this.$get(reverseKey) ? -1 : 1
+        }
+    }
+
+    // sort on a copy to avoid mutating original array
+    return arr.slice().sort(function (a, b) {
+        a = get(a, key)
+        b = get(b, key)
+        return a === b ? 0 : a > b ? order : -order
+    })
+
+}
+
+filters.orderBy.computed = true
+
+// Array filter helpers -------------------------------------------------------
+
+/**
+ *  String contain helper
+ */
+function contains (val, search) {
+    /* jshint eqeqeq: false */
+    if (utils.isObject(val)) {
+        for (var key in val) {
+            if (contains(val[key], search)) {
+                return true
+            }
+        }
+    } else if (val != null) {
+        return val.toString().toLowerCase().indexOf(search) > -1
+    }
+}
+
+/**
+ *  Test whether a string is in quotes,
+ *  if yes return stripped string
+ */
+function stripQuotes (str) {
+    if (QUOTE_RE.test(str)) {
+        return str.slice(1, -1)
+    }
+}