fluentd-ui 0.3.8 → 0.3.9

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

@@ -1,191 +0,0 @@
-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) {
-    value = parseFloat(value)
-    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)
-    }
-}

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

@@ -1,67 +0,0 @@
-// string -> DOM conversion
-// wrappers originally from jQuery, scooped from component/domify
-var map = {
-    legend   : [1, '<fieldset>', '</fieldset>'],
-    tr       : [2, '<table><tbody>', '</tbody></table>'],
-    col      : [2, '<table><tbody></tbody><colgroup>', '</colgroup></table>'],
-    _default : [0, '', '']
-}
-
-map.td =
-map.th = [3, '<table><tbody><tr>', '</tr></tbody></table>']
-
-map.option =
-map.optgroup = [1, '<select multiple="multiple">', '</select>']
-
-map.thead =
-map.tbody =
-map.colgroup =
-map.caption =
-map.tfoot = [1, '<table>', '</table>']
-
-map.text =
-map.circle =
-map.ellipse =
-map.line =
-map.path =
-map.polygon =
-map.polyline =
-map.rect = [1, '<svg xmlns="http://www.w3.org/2000/svg" version="1.1">','</svg>']
-
-var TAG_RE = /<([\w:]+)/
-
-module.exports = function (templateString) {
-    var frag = document.createDocumentFragment(),
-        m = TAG_RE.exec(templateString)
-    // text only
-    if (!m) {
-        frag.appendChild(document.createTextNode(templateString))
-        return frag
-    }
-
-    var tag = m[1],
-        wrap = map[tag] || map._default,
-        depth = wrap[0],
-        prefix = wrap[1],
-        suffix = wrap[2],
-        node = document.createElement('div')
-
-    node.innerHTML = prefix + templateString.trim() + suffix
-    while (depth--) node = node.lastChild
-
-    // one element
-    if (node.firstChild === node.lastChild) {
-        frag.appendChild(node.firstChild)
-        return frag
-    }
-
-    // multiple nodes, return a fragment
-    var child
-    /* jshint boss: true */
-    while (child = node.firstChild) {
-        if (node.nodeType === 1) {
-            frag.appendChild(child)
-        }
-    }
-    return frag
-}

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

@@ -1,188 +0,0 @@
-var config      = require('./config'),
-    ViewModel   = require('./viewmodel'),
-    utils       = require('./utils'),
-    makeHash    = utils.hash,
-    assetTypes  = ['directive', 'filter', 'partial', 'effect', 'component'],
-    // Internal modules that are exposed for plugins
-    pluginAPI   = {
-        utils: utils,
-        config: config,
-        transition: require('./transition'),
-        observer: require('./observer')
-    }
-
-ViewModel.options = config.globalAssets = {
-    directives  : require('./directives'),
-    filters     : require('./filters'),
-    partials    : makeHash(),
-    effects     : makeHash(),
-    components  : makeHash()
-}
-
-/**
- *  Expose asset registration methods
- */
-assetTypes.forEach(function (type) {
-    ViewModel[type] = function (id, value) {
-        var hash = this.options[type + 's']
-        if (!hash) {
-            hash = this.options[type + 's'] = makeHash()
-        }
-        if (!value) return hash[id]
-        if (type === 'partial') {
-            value = utils.parseTemplateOption(value)
-        } else if (type === 'component') {
-            value = utils.toConstructor(value)
-        } else if (type === 'filter') {
-            utils.checkFilter(value)
-        }
-        hash[id] = value
-        return this
-    }
-})
-
-/**
- *  Set config options
- */
-ViewModel.config = function (opts, val) {
-    if (typeof opts === 'string') {
-        if (val === undefined) {
-            return config[opts]
-        } else {
-            config[opts] = val
-        }
-    } else {
-        utils.extend(config, opts)
-    }
-    return this
-}
-
-/**
- *  Expose an interface for plugins
- */
-ViewModel.use = function (plugin) {
-    if (typeof plugin === 'string') {
-        try {
-            plugin = require(plugin)
-        } catch (e) {
-            utils.warn('Cannot find plugin: ' + plugin)
-            return
-        }
-    }
-
-    // additional parameters
-    var args = [].slice.call(arguments, 1)
-    args.unshift(this)
-
-    if (typeof plugin.install === 'function') {
-        plugin.install.apply(plugin, args)
-    } else {
-        plugin.apply(null, args)
-    }
-    return this
-}
-
-/**
- *  Expose internal modules for plugins
- */
-ViewModel.require = function (module) {
-    return pluginAPI[module]
-}
-
-ViewModel.extend = extend
-ViewModel.nextTick = utils.nextTick
-
-/**
- *  Expose the main ViewModel class
- *  and add extend method
- */
-function extend (options) {
-
-    var ParentVM = this
-
-    // extend data options need to be copied
-    // on instantiation
-    if (options.data) {
-        options.defaultData = options.data
-        delete options.data
-    }
-
-    // inherit options
-    // but only when the super class is not the native Vue.
-    if (ParentVM !== ViewModel) {
-        options = inheritOptions(options, ParentVM.options, true)
-    }
-    utils.processOptions(options)
-
-    var ExtendedVM = function (opts, asParent) {
-        if (!asParent) {
-            opts = inheritOptions(opts, options, true)
-        }
-        ParentVM.call(this, opts, true)
-    }
-
-    // inherit prototype props
-    var proto = ExtendedVM.prototype = Object.create(ParentVM.prototype)
-    utils.defProtected(proto, 'constructor', ExtendedVM)
-
-    // allow extended VM to be further extended
-    ExtendedVM.extend  = extend
-    ExtendedVM.super   = ParentVM
-    ExtendedVM.options = options
-
-    // allow extended VM to add its own assets
-    assetTypes.forEach(function (type) {
-        ExtendedVM[type] = ViewModel[type]
-    })
-
-    // allow extended VM to use plugins
-    ExtendedVM.use     = ViewModel.use
-    ExtendedVM.require = ViewModel.require
-
-    return ExtendedVM
-}
-
-/**
- *  Inherit options
- *
- *  For options such as `data`, `vms`, `directives`, 'partials',
- *  they should be further extended. However extending should only
- *  be done at top level.
- *  
- *  `proto` is an exception because it's handled directly on the
- *  prototype.
- *
- *  `el` is an exception because it's not allowed as an
- *  extension option, but only as an instance option.
- */
-function inheritOptions (child, parent, topLevel) {
-    child = child || {}
-    if (!parent) return child
-    for (var key in parent) {
-        if (key === 'el') continue
-        var val = child[key],
-            parentVal = parent[key]
-        if (topLevel && typeof val === 'function' && parentVal) {
-            // merge hook functions into an array
-            child[key] = [val]
-            if (Array.isArray(parentVal)) {
-                child[key] = child[key].concat(parentVal)
-            } else {
-                child[key].push(parentVal)
-            }
-        } else if (
-            topLevel &&
-            (utils.isTrueObject(val) || utils.isTrueObject(parentVal))
-            && !(parentVal instanceof ViewModel)
-        ) {
-            // merge toplevel object options
-            child[key] = inheritOptions(val, parentVal)
-        } else if (val === undefined) {
-            // inherit if child doesn't override
-            child[key] = parentVal
-        }
-    }
-    return child
-}
-
-module.exports = ViewModel

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

@@ -1,446 +0,0 @@
-/* jshint proto:true */
-
-var Emitter  = require('./emitter'),
-    utils    = require('./utils'),
-    // cache methods
-    def      = utils.defProtected,
-    isObject = utils.isObject,
-    isArray  = Array.isArray,
-    hasOwn   = ({}).hasOwnProperty,
-    oDef     = Object.defineProperty,
-    slice    = [].slice,
-    // fix for IE + __proto__ problem
-    // define methods as inenumerable if __proto__ is present,
-    // otherwise enumerable so we can loop through and manually
-    // attach to array instances
-    hasProto = ({}).__proto__
-
-// Array Mutation Handlers & Augmentations ------------------------------------
-
-// The proxy prototype to replace the __proto__ of
-// an observed array
-var ArrayProxy = Object.create(Array.prototype)
-
-// intercept mutation methods
-;[
-    'push',
-    'pop',
-    'shift',
-    'unshift',
-    'splice',
-    'sort',
-    'reverse'
-].forEach(watchMutation)
-
-// Augment the ArrayProxy with convenience methods
-def(ArrayProxy, '$set', function (index, data) {
-    return this.splice(index, 1, data)[0]
-}, !hasProto)
-
-def(ArrayProxy, '$remove', function (index) {
-    if (typeof index !== 'number') {
-        index = this.indexOf(index)
-    }
-    if (index > -1) {
-        return this.splice(index, 1)[0]
-    }
-}, !hasProto)
-
-/**
- *  Intercep a mutation event so we can emit the mutation info.
- *  we also analyze what elements are added/removed and link/unlink
- *  them with the parent Array.
- */
-function watchMutation (method) {
-    def(ArrayProxy, method, function () {
-
-        var args = slice.call(arguments),
-            result = Array.prototype[method].apply(this, args),
-            inserted, removed
-
-        // determine new / removed elements
-        if (method === 'push' || method === 'unshift') {
-            inserted = args
-        } else if (method === 'pop' || method === 'shift') {
-            removed = [result]
-        } else if (method === 'splice') {
-            inserted = args.slice(2)
-            removed = result
-        }
-        
-        // link & unlink
-        linkArrayElements(this, inserted)
-        unlinkArrayElements(this, removed)
-
-        // emit the mutation event
-        this.__emitter__.emit('mutate', '', this, {
-            method   : method,
-            args     : args,
-            result   : result,
-            inserted : inserted,
-            removed  : removed
-        })
-
-        return result
-        
-    }, !hasProto)
-}
-
-/**
- *  Link new elements to an Array, so when they change
- *  and emit events, the owner Array can be notified.
- */
-function linkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item, owners
-        while (i--) {
-            item = items[i]
-            if (isWatchable(item)) {
-                // if object is not converted for observing
-                // convert it...
-                if (!item.__emitter__) {
-                    convert(item)
-                    watch(item)
-                }
-                owners = item.__emitter__.owners
-                if (owners.indexOf(arr) < 0) {
-                    owners.push(arr)
-                }
-            }
-        }
-    }
-}
-
-/**
- *  Unlink removed elements from the ex-owner Array.
- */
-function unlinkArrayElements (arr, items) {
-    if (items) {
-        var i = items.length, item
-        while (i--) {
-            item = items[i]
-            if (item && item.__emitter__) {
-                var owners = item.__emitter__.owners
-                if (owners) owners.splice(owners.indexOf(arr))
-            }
-        }
-    }
-}
-
-// Object add/delete key augmentation -----------------------------------------
-
-var ObjProxy = Object.create(Object.prototype)
-
-def(ObjProxy, '$add', function (key, val) {
-    if (hasOwn.call(this, key)) return
-    this[key] = val
-    convertKey(this, key, true)
-}, !hasProto)
-
-def(ObjProxy, '$delete', function (key) {
-    if (!(hasOwn.call(this, key))) return
-    // trigger set events
-    this[key] = undefined
-    delete this[key]
-    this.__emitter__.emit('delete', key)
-}, !hasProto)
-
-// Watch Helpers --------------------------------------------------------------
-
-/**
- *  Check if a value is watchable
- */
-function isWatchable (obj) {
-    return typeof obj === 'object' && obj && !obj.$compiler
-}
-
-/**
- *  Convert an Object/Array to give it a change emitter.
- */
-function convert (obj) {
-    if (obj.__emitter__) return true
-    var emitter = new Emitter()
-    def(obj, '__emitter__', emitter)
-    emitter
-        .on('set', function (key, val, propagate) {
-            if (propagate) propagateChange(obj)
-        })
-        .on('mutate', function () {
-            propagateChange(obj)
-        })
-    emitter.values = utils.hash()
-    emitter.owners = []
-    return false
-}
-
-/**
- *  Propagate an array element's change to its owner arrays
- */
-function propagateChange (obj) {
-    var owners = obj.__emitter__.owners,
-        i = owners.length
-    while (i--) {
-        owners[i].__emitter__.emit('set', '', '', true)
-    }
-}
-
-/**
- *  Watch target based on its type
- */
-function watch (obj) {
-    if (isArray(obj)) {
-        watchArray(obj)
-    } else {
-        watchObject(obj)
-    }
-}
-
-/**
- *  Augment target objects with modified
- *  methods
- */
-function augment (target, src) {
-    if (hasProto) {
-        target.__proto__ = src
-    } else {
-        for (var key in src) {
-            def(target, key, src[key])
-        }
-    }
-}
-
-/**
- *  Watch an Object, recursive.
- */
-function watchObject (obj) {
-    augment(obj, ObjProxy)
-    for (var key in obj) {
-        convertKey(obj, key)
-    }
-}
-
-/**
- *  Watch an Array, overload mutation methods
- *  and add augmentations by intercepting the prototype chain
- */
-function watchArray (arr) {
-    augment(arr, ArrayProxy)
-    linkArrayElements(arr, arr)
-}
-
-/**
- *  Define accessors for a property on an Object
- *  so it emits get/set events.
- *  Then watch the value itself.
- */
-function convertKey (obj, key, propagate) {
-    var keyPrefix = key.charAt(0)
-    if (keyPrefix === '$' || keyPrefix === '_') {
-        return
-    }
-    // emit set on bind
-    // this means when an object is observed it will emit
-    // a first batch of set events.
-    var emitter = obj.__emitter__,
-        values  = emitter.values
-
-    init(obj[key], propagate)
-
-    oDef(obj, key, {
-        enumerable: true,
-        configurable: true,
-        get: function () {
-            var value = values[key]
-            // only emit get on tip values
-            if (pub.shouldGet) {
-                emitter.emit('get', key)
-            }
-            return value
-        },
-        set: function (newVal) {
-            var oldVal = values[key]
-            unobserve(oldVal, key, emitter)
-            copyPaths(newVal, oldVal)
-            // an immediate property should notify its parent
-            // to emit set for itself too
-            init(newVal, true)
-        }
-    })
-
-    function init (val, propagate) {
-        values[key] = val
-        emitter.emit('set', key, val, propagate)
-        if (isArray(val)) {
-            emitter.emit('set', key + '.length', val.length, propagate)
-        }
-        observe(val, key, emitter)
-    }
-}
-
-/**
- *  When a value that is already converted is
- *  observed again by another observer, we can skip
- *  the watch conversion and simply emit set event for
- *  all of its properties.
- */
-function emitSet (obj) {
-    var emitter = obj && obj.__emitter__
-    if (!emitter) return
-    if (isArray(obj)) {
-        emitter.emit('set', 'length', obj.length)
-    } else {
-        var key, val
-        for (key in obj) {
-            val = obj[key]
-            emitter.emit('set', key, val)
-            emitSet(val)
-        }
-    }
-}
-
-/**
- *  Make sure all the paths in an old object exists
- *  in a new object.
- *  So when an object changes, all missing keys will
- *  emit a set event with undefined value.
- */
-function copyPaths (newObj, oldObj) {
-    if (!isObject(newObj) || !isObject(oldObj)) {
-        return
-    }
-    var path, oldVal, newVal
-    for (path in oldObj) {
-        if (!(hasOwn.call(newObj, path))) {
-            oldVal = oldObj[path]
-            if (isArray(oldVal)) {
-                newObj[path] = []
-            } else if (isObject(oldVal)) {
-                newVal = newObj[path] = {}
-                copyPaths(newVal, oldVal)
-            } else {
-                newObj[path] = undefined
-            }
-        }
-    }
-}
-
-/**
- *  walk along a path and make sure it can be accessed
- *  and enumerated in that object
- */
-function ensurePath (obj, key) {
-    var path = key.split('.'), sec
-    for (var i = 0, d = path.length - 1; i < d; i++) {
-        sec = path[i]
-        if (!obj[sec]) {
-            obj[sec] = {}
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-        obj = obj[sec]
-    }
-    if (isObject(obj)) {
-        sec = path[i]
-        if (!(hasOwn.call(obj, sec))) {
-            obj[sec] = undefined
-            if (obj.__emitter__) convertKey(obj, sec)
-        }
-    }
-}
-
-// Main API Methods -----------------------------------------------------------
-
-/**
- *  Observe an object with a given path,
- *  and proxy get/set/mutate events to the provided observer.
- */
-function observe (obj, rawPath, observer) {
-
-    if (!isWatchable(obj)) return
-
-    var path = rawPath ? rawPath + '.' : '',
-        alreadyConverted = convert(obj),
-        emitter = obj.__emitter__
-
-    // setup proxy listeners on the parent observer.
-    // we need to keep reference to them so that they
-    // can be removed when the object is un-observed.
-    observer.proxies = observer.proxies || {}
-    var proxies = observer.proxies[path] = {
-        get: function (key) {
-            observer.emit('get', path + key)
-        },
-        set: function (key, val, propagate) {
-            if (key) observer.emit('set', path + key, val)
-            // also notify observer that the object itself changed
-            // but only do so when it's a immediate property. this
-            // avoids duplicate event firing.
-            if (rawPath && propagate) {
-                observer.emit('set', rawPath, obj, true)
-            }
-        },
-        mutate: function (key, val, mutation) {
-            // if the Array is a root value
-            // the key will be null
-            var fixedPath = key ? path + key : rawPath
-            observer.emit('mutate', fixedPath, val, mutation)
-            // also emit set for Array's length when it mutates
-            var m = mutation.method
-            if (m !== 'sort' && m !== 'reverse') {
-                observer.emit('set', fixedPath + '.length', val.length)
-            }
-        }
-    }
-
-    // attach the listeners to the child observer.
-    // now all the events will propagate upwards.
-    emitter
-        .on('get', proxies.get)
-        .on('set', proxies.set)
-        .on('mutate', proxies.mutate)
-
-    if (alreadyConverted) {
-        // for objects that have already been converted,
-        // emit set events for everything inside
-        emitSet(obj)
-    } else {
-        watch(obj)
-    }
-}
-
-/**
- *  Cancel observation, turn off the listeners.
- */
-function unobserve (obj, path, observer) {
-
-    if (!obj || !obj.__emitter__) return
-
-    path = path ? path + '.' : ''
-    var proxies = observer.proxies[path]
-    if (!proxies) return
-
-    // turn off listeners
-    obj.__emitter__
-        .off('get', proxies.get)
-        .off('set', proxies.set)
-        .off('mutate', proxies.mutate)
-
-    // remove reference
-    observer.proxies[path] = null
-}
-
-// Expose API -----------------------------------------------------------------
-
-var pub = module.exports = {
-
-    // whether to emit get events
-    // only enabled during dependency parsing
-    shouldGet   : false,
-
-    observe     : observe,
-    unobserve   : unobserve,
-    ensurePath  : ensurePath,
-    copyPaths   : copyPaths,
-    watch       : watch,
-    convert     : convert,
-    convertKey  : convertKey
-}