kitchensink

<!doctype html> <html lang="en"> <head> <title>Code coverage report for index.js</title> <meta charset="utf-8"> <link rel="stylesheet" href="../prettify.css"> <link rel="stylesheet" href="../base.css"> <style type='text/css'> div.coverage-summary .sorter { background-image: url(../sort-arrow-sprite.png); } </style> </head> <body> <div class="header medium"> <h1>Code coverage report for index.js</h1> <h2> Statements: 69% (69 / 100)      Branches: 74.42% (64 / 86)      Functions: 100% (4 / 4)      Lines: 69.23% (63 / 91)      Ignored: none      </h2> <div class="path"><a href="../index.html">All files</a> » <a href="index.html">__root__/</a> » index.js</div> </div> <div class="body"> <pre><table class="coverage"> <tr><td class="line-count">1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173</td><td class="line-coverage">    1 108     1   1 49     1 1                                                             1     1 105   105 40 40   65 1 1   64 5 5   59 2 2   57       57 2 2   55       55 2 2 2   53       53       53       53       53       53       53       53 10 10   43 4 4           39                               39 39 39 39     39         37 37 37 36 36   36 36 54 54 54     30   30 30            </td><td class="text"><pre class="prettyprint lang-js">'use strict'   function isArguments (obj) { return Object.prototype.toString.call(obj) === '[object Arguments]' }   module.exports = match   function match (obj, pattern) { return match_(obj, pattern, [], []) }   try { match.fastEqual = require('buffertools').equals } catch (e) { // whoops, nobody told buffertools it wasn't installed }   /** 1. If the object is a string, and the pattern is a RegExp, then return true if `pattern.test(object)`. 2. Use loose equality (`==`) only for all other value types (non-objects). `tmatch` cares more about shape and contents than type. This step will also catch functions, with the useful (default) property that only references to the same function are considered equal. 'Ware the halting problem! 3. `null` *is* an object – a singleton value object, in fact – so if either is `null`, return object == pattern. 4. Since the only way to make it this far is for `object` or `pattern` to be an object, if `object` or `pattern` is *not* an object, they're clearly not a match. 5. It's much faster to compare dates by numeric value (`.getTime()`) than by lexical value. 6. Compare RegExps by their components, not the objects themselves. 7. The parts of an arguments list most people care about are the arguments themselves, not the callee, which you shouldn't be looking at anyway. 8. Objects are more complex: 1. Return `true` if `object` and `pattern` both have no properties. 2. Ensure that cyclical references don't blow up the stack. 3. Ensure that all the key names in `pattern` exist in `object`. 4. Ensure that all of the associated values match, recursively. */   var log = (/\btmatch\b/.test(process.env.NODE_DEBUG || '')) ? console.error : function () {}   function match_ (obj, pattern, ca, cb) { log('TMATCH', typeof obj, pattern) /*eslint eqeqeq:0*/ if (obj == pattern) { log('TMATCH same object or simple value, true') return true   } else if (obj === null || pattern === null) { log('TMATCH null test') return obj == pattern   } else if (typeof obj === 'string' && pattern instanceof RegExp) { log('TMATCH string~=regexp test') return pattern.test(obj)   } else if (typeof obj === 'string' && typeof pattern === 'string' && pattern) { log('TMATCH string~=string test') return obj.indexOf(pattern) !== -1   } else Iif (pattern === Buffer) { log('TMATCH Buffer ctor') return Buffer.isBuffer(obj)   } else if (obj instanceof Date && pattern instanceof Date) { log('TMATCH date test') return obj.getTime() === pattern.getTime()   } else Iif (obj instanceof Date && typeof pattern === 'string') { log('TMATCH date~=string test') return obj.getTime() === new Date(pattern).getTime()   } else if (isArguments(obj) || isArguments(pattern)) { log('TMATCH arguments test') var slice = Array.prototype.slice return match_(slice.call(obj), slice.call(pattern), ca, cb)   } else Iif (pattern === Function) { log('TMATCH Function ctor') return typeof obj === 'function'   } else Iif (pattern === Number) { log('TMATCH Number ctor') return typeof obj === 'number' && obj === obj   } else Iif (pattern !== pattern) { log('TMATCH NaN') return obj !== obj   } else Iif (pattern === String) { log('TMATCH String ctor') return typeof obj === 'string'   } else Iif (pattern === Boolean) { log('TMATCH Boolean ctor') return typeof obj === 'boolean'   } else Iif (pattern === Array) { log('TMATCH Array ctor') return Array.isArray(pattern)   } else Iif (typeof pattern === 'function' && typeof obj === 'object') { log('TMATCH object~=function') return obj instanceof pattern   } else if (typeof obj !== 'object' || typeof pattern !== 'object') { log('TMATCH obj is not object, pattern is not object, false') return false   } else if (obj instanceof RegExp && pattern instanceof RegExp) { log('TMATCH regexp~=regexp test') return obj.source === pattern.source && obj.global === pattern.global && obj.multiline === pattern.multiline && obj.lastIndex === pattern.lastIndex && obj.ignoreCase === pattern.ignoreCase   } else Iif (Buffer.isBuffer(obj) && Buffer.isBuffer(pattern)) { log('TMATCH buffer test') if (obj.equals) { return obj.equals(pattern) } else if (match.fastEqual) { return match.fastEqual.call(obj, pattern) } else { if (obj.length !== pattern.length) return false   for (var j = 0; j < obj.length; j++) if (obj[j] != pattern[j]) return false   return true }   } else { // both are objects. interesting case! log('TMATCH object~=object test') var kobj = Object.keys(obj) var kpat = Object.keys(pattern) log(' TMATCH patternkeys=%j objkeys=%j', kpat, kobj)   // don't bother with stack acrobatics if there's nothing there if (kobj.length === 0 && kpat.length === 0) return true   // if we've seen this exact pattern and object already, then // it means that pattern and obj have matching cyclicalness // however, non-cyclical patterns can match cyclical objects log(' TMATCH check seen objects...') var cal = ca.length while (cal--) if (ca[cal] === obj && cb[cal] === pattern) return true ca.push(obj); cb.push(pattern) log(' TMATCH not seen previously')   var key for (var l = kpat.length - 1; l >= 0; l--) { key = kpat[l] log(' TMATCH test obj[%j]', key, obj[key], pattern[key]) if (!match_(obj[key], pattern[key], ca, cb)) return false }   ca.pop(); cb.pop()   log(' TMATCH object pass') return true }   log('TMATCH no way to match') return false }  </pre></td></tr> </table></pre> </div> <div class="footer"> <div class="meta">Generated by <a href="http://istanbul-js.org/" target="_blank">istanbul</a> at Tue Feb 16 2016 13:45:26 GMT-0800 (PST)</div> </div> <script src="../prettify.js"></script> <script> window.onload = function () { if (typeof prettyPrint === 'function') { prettyPrint(); } }; </script> <script src="../sorter.js"></script> </body> </html>