fluentd-ui 0.3.13 → 0.3.14

data/vendor/assets/javascripts/bower/vue/src/parsers/expression.js

@@ -1,226 +0,0 @@
-var _ = require('../util')
-var Path = require('./path')
-var Cache = require('../cache')
-var expressionCache = new Cache(1000)
-
-var keywords =
-  'Math,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,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,' +
-  'arguments,let,yield'
-
-var wsRE = /\s/g
-var newlineRE = /\n/g
-var saveRE = /[\{,]\s*[\w\$_]+\s*:|'[^']*'|"[^"]*"/g
-var restoreRE = /"(\d+)"/g
-var pathTestRE = /^[A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\]|\[\d+\])*$/
-var pathReplaceRE = /[^\w$\.]([A-Za-z_$][\w$]*(\.[A-Za-z_$][\w$]*|\['.*?'\]|\[".*?"\])*)/g
-var keywordsRE = new RegExp('^(' + keywords.replace(/,/g, '\\b|') + '\\b)')
-
-/**
- * Save / Rewrite / Restore
- *
- * When rewriting paths found in an expression, it is
- * possible for the same letter sequences to be found in
- * strings and Object literal property keys. Therefore we
- * remove and store these parts in a temporary array, and
- * restore them after the path rewrite.
- */
-
-var saved = []
-
-/**
- * Save replacer
- *
- * @param {String} str
- * @return {String} - placeholder with index
- */
-
-function save (str) {
-  var i = saved.length
-  saved[i] = str.replace(newlineRE, '\\n')
-  return '"' + i + '"'
-}
-
-/**
- * Path rewrite replacer
- *
- * @param {String} raw
- * @return {String}
- */
-
-function rewrite (raw) {
-  var c = raw.charAt(0)
-  var path = raw.slice(1)
-  if (keywordsRE.test(path)) {
-    return raw
-  } else {
-    path = path.indexOf('"') > -1
-      ? path.replace(restoreRE, restore)
-      : path
-    return c + 'scope.' + path
-  }
-}
-
-/**
- * Restore replacer
- *
- * @param {String} str
- * @param {String} i - matched save index
- * @return {String}
- */
-
-function restore (str, i) {
-  return saved[i]
-}
-
-/**
- * Rewrite an expression, prefixing all path accessors with
- * `scope.` and generate getter/setter functions.
- *
- * @param {String} exp
- * @param {Boolean} needSet
- * @return {Function}
- */
-
-function compileExpFns (exp, needSet) {
-  // reset state
-  saved.length = 0
-  // save strings and object literal keys
-  var body = exp
-    .replace(saveRE, save)
-    .replace(wsRE, '')
-  // rewrite all paths
-  // pad 1 space here becaue the regex matches 1 extra char
-  body = (' ' + body)
-    .replace(pathReplaceRE, rewrite)
-    .replace(restoreRE, restore)
-  var getter = makeGetter(body)
-  if (getter) {
-    return {
-      get: getter,
-      body: body,
-      set: needSet
-        ? makeSetter(body)
-        : null
-    }
-  }
-}
-
-/**
- * Compile getter setters for a simple path.
- *
- * @param {String} exp
- * @return {Function}
- */
-
-function compilePathFns (exp) {
-  var getter, path
-  if (exp.indexOf('[') < 0) {
-    // really simple path
-    path = exp.split('.')
-    getter = Path.compileGetter(path)
-  } else {
-    // do the real parsing
-    path = Path.parse(exp)
-    getter = path.get
-  }
-  return {
-    get: getter,
-    // always generate setter for simple paths
-    set: function (obj, val) {
-      Path.set(obj, path, val)
-    }
-  }
-}
-
-/**
- * Build a getter function. Requires eval.
- *
- * We isolate the try/catch so it doesn't affect the
- * optimization of the parse function when it is not called.
- *
- * @param {String} body
- * @return {Function|undefined}
- */
-
-function makeGetter (body) {
-  try {
-    return new Function('scope', 'return ' + body + ';')
-  } catch (e) {
-    _.warn(
-      'Invalid expression. ' +
-      'Generated function body: ' + body
-    )
-  }
-}
-
-/**
- * Build a setter function.
- *
- * This is only needed in rare situations like "a[b]" where
- * a settable path requires dynamic evaluation.
- *
- * This setter function may throw error when called if the
- * expression body is not a valid left-hand expression in
- * assignment.
- *
- * @param {String} body
- * @return {Function|undefined}
- */
-
-function makeSetter (body) {
-  try {
-    return new Function('scope', 'value', body + '=value;')
-  } catch (e) {
-    _.warn('Invalid setter function body: ' + body)
-  }
-}
-
-/**
- * Check for setter existence on a cache hit.
- *
- * @param {Function} hit
- */
-
-function checkSetter (hit) {
-  if (!hit.set) {
-    hit.set = makeSetter(hit.body)
-  }
-}
-
-/**
- * Parse an expression into re-written getter/setters.
- *
- * @param {String} exp
- * @param {Boolean} needSet
- * @return {Function}
- */
-
-exports.parse = function (exp, needSet) {
-  exp = exp.trim()
-  // try cache
-  var hit = expressionCache.get(exp)
-  if (hit) {
-    if (needSet) {
-      checkSetter(hit)
-    }
-    return hit
-  }
-  // we do a simple path check to optimize for them.
-  // the check fails valid paths with unusal whitespaces,
-  // but that's too rare and we don't care.
-  var res = pathTestRE.test(exp)
-    ? compilePathFns(exp)
-    : compileExpFns(exp, needSet)
-  expressionCache.put(exp, res)
-  return res
-}
-
-// Export the pathRegex for external use
-exports.pathTestRE = pathTestRE

data/vendor/assets/javascripts/bower/vue/src/parsers/path.js

@@ -1,300 +0,0 @@
-var _ = require('../util')
-var Cache = require('../cache')
-var pathCache = new Cache(1000)
-var identRE = /^[$_a-zA-Z]+[\w$]*$/
-
-/**
- * Path-parsing algorithm scooped from Polymer/observe-js
- */
-
-var pathStateMachine = {
-  'beforePath': {
-    'ws': ['beforePath'],
-    'ident': ['inIdent', 'append'],
-    '[': ['beforeElement'],
-    'eof': ['afterPath']
-  },
-
-  'inPath': {
-    'ws': ['inPath'],
-    '.': ['beforeIdent'],
-    '[': ['beforeElement'],
-    'eof': ['afterPath']
-  },
-
-  'beforeIdent': {
-    'ws': ['beforeIdent'],
-    'ident': ['inIdent', 'append']
-  },
-
-  'inIdent': {
-    'ident': ['inIdent', 'append'],
-    '0': ['inIdent', 'append'],
-    'number': ['inIdent', 'append'],
-    'ws': ['inPath', 'push'],
-    '.': ['beforeIdent', 'push'],
-    '[': ['beforeElement', 'push'],
-    'eof': ['afterPath', 'push']
-  },
-
-  'beforeElement': {
-    'ws': ['beforeElement'],
-    '0': ['afterZero', 'append'],
-    'number': ['inIndex', 'append'],
-    "'": ['inSingleQuote', 'append', ''],
-    '"': ['inDoubleQuote', 'append', '']
-  },
-
-  'afterZero': {
-    'ws': ['afterElement', 'push'],
-    ']': ['inPath', 'push']
-  },
-
-  'inIndex': {
-    '0': ['inIndex', 'append'],
-    'number': ['inIndex', 'append'],
-    'ws': ['afterElement'],
-    ']': ['inPath', 'push']
-  },
-
-  'inSingleQuote': {
-    "'": ['afterElement'],
-    'eof': 'error',
-    'else': ['inSingleQuote', 'append']
-  },
-
-  'inDoubleQuote': {
-    '"': ['afterElement'],
-    'eof': 'error',
-    'else': ['inDoubleQuote', 'append']
-  },
-
-  'afterElement': {
-    'ws': ['afterElement'],
-    ']': ['inPath', 'push']
-  }
-}
-
-function noop () {}
-
-/**
- * Determine the type of a character in a keypath.
- *
- * @param {Char} char
- * @return {String} type
- */
-
-function getPathCharType (char) {
-  if (char === undefined) {
-    return 'eof'
-  }
-
-  var code = char.charCodeAt(0)
-
-  switch(code) {
-    case 0x5B: // [
-    case 0x5D: // ]
-    case 0x2E: // .
-    case 0x22: // "
-    case 0x27: // '
-    case 0x30: // 0
-      return char
-
-    case 0x5F: // _
-    case 0x24: // $
-      return 'ident'
-
-    case 0x20: // Space
-    case 0x09: // Tab
-    case 0x0A: // Newline
-    case 0x0D: // Return
-    case 0xA0:  // No-break space
-    case 0xFEFF:  // Byte Order Mark
-    case 0x2028:  // Line Separator
-    case 0x2029:  // Paragraph Separator
-      return 'ws'
-  }
-
-  // a-z, A-Z
-  if ((0x61 <= code && code <= 0x7A) ||
-      (0x41 <= code && code <= 0x5A)) {
-    return 'ident'
-  }
-
-  // 1-9
-  if (0x31 <= code && code <= 0x39) {
-    return 'number'
-  }
-
-  return 'else'
-}
-
-/**
- * Parse a string path into an array of segments
- * Todo implement cache
- *
- * @param {String} path
- * @return {Array|undefined}
- */
-
-function parsePath (path) {
-  var keys = []
-  var index = -1
-  var mode = 'beforePath'
-  var c, newChar, key, type, transition, action, typeMap
-
-  var actions = {
-    push: function() {
-      if (key === undefined) {
-        return
-      }
-      keys.push(key)
-      key = undefined
-    },
-    append: function() {
-      if (key === undefined) {
-        key = newChar
-      } else {
-        key += newChar
-      }
-    }
-  }
-
-  function maybeUnescapeQuote () {
-    var nextChar = path[index + 1]
-    if ((mode === 'inSingleQuote' && nextChar === "'") ||
-        (mode === 'inDoubleQuote' && nextChar === '"')) {
-      index++
-      newChar = nextChar
-      actions.append()
-      return true
-    }
-  }
-
-  while (mode) {
-    index++
-    c = path[index]
-
-    if (c === '\\' && maybeUnescapeQuote()) {
-      continue
-    }
-
-    type = getPathCharType(c)
-    typeMap = pathStateMachine[mode]
-    transition = typeMap[type] || typeMap['else'] || 'error'
-
-    if (transition === 'error') {
-      return // parse error
-    }
-
-    mode = transition[0]
-    action = actions[transition[1]] || noop
-    newChar = transition[2] === undefined
-      ? c
-      : transition[2]
-    action()
-
-    if (mode === 'afterPath') {
-      return keys
-    }
-  }
-}
-
-/**
- * Format a accessor segment based on its type.
- *
- * @param {String} key
- * @return {Boolean}
- */
-
-function formatAccessor(key) {
-  if (identRE.test(key)) { // identifier
-    return '.' + key
-  } else if (+key === key >>> 0) { // bracket index
-    return '[' + key + ']'
-  } else { // bracket string
-    return '["' + key.replace(/"/g, '\\"') + '"]'
-  }
-}
-
-/**
- * Compiles a getter function with a fixed path.
- *
- * @param {Array} path
- * @return {Function}
- */
-
-exports.compileGetter = function (path) {
-  var body =
-    'try{return o' +
-    path.map(formatAccessor).join('') +
-    '}catch(e){};'
-  return new Function('o', body)
-}
-
-/**
- * External parse that check for a cache hit first
- *
- * @param {String} path
- * @return {Array|undefined}
- */
-
-exports.parse = function (path) {
-  var hit = pathCache.get(path)
-  if (!hit) {
-    hit = parsePath(path)
-    if (hit) {
-      hit.get = exports.compileGetter(hit)
-      pathCache.put(path, hit)
-    }
-  }
-  return hit
-}
-
-/**
- * Get from an object from a path string
- *
- * @param {Object} obj
- * @param {String} path
- */
-
-exports.get = function (obj, path) {
-  path = exports.parse(path)
-  if (path) {
-    return path.get(obj)
-  }
-}
-
-/**
- * Set on an object from a path
- *
- * @param {Object} obj
- * @param {String | Array} path
- * @param {*} val
- */
-
-exports.set = function (obj, path, val) {
-  if (typeof path === 'string') {
-    path = exports.parse(path)
-  }
-  if (!path || !_.isObject(obj)) {
-    return false
-  }
-  var last, key
-  for (var i = 0, l = path.length - 1; i < l; i++) {
-    last = obj
-    key = path[i]
-    obj = obj[key]
-    if (!_.isObject(obj)) {
-      obj = {}
-      last.$add(key, obj)
-    }
-  }
-  key = path[i]
-  if (key in obj) {
-    obj[key] = val
-  } else {
-    obj.$add(key, val)
-  }
-  return true
-}