http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/caseless/LICENSE ---------------------------------------------------------------------- diff --git a/node_modules/caseless/LICENSE b/node_modules/caseless/LICENSE new file mode 100644 index 0000000..61789f4 --- /dev/null +++ b/node_modules/caseless/LICENSE @@ -0,0 +1,28 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION +1. Definitions. +"License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. +"Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. +"Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. +"You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. +"Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. +"Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. +"Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). +"Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. +"Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. +2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. +3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. +4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: +You must give any other recipients of the Work or Derivative Works a copy of this License; and +You must cause any modified files to carry prominent notices stating that You changed the files; and +You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and +If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modi fications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. +5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. +6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. +7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. +8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. +9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. +END OF TERMS AND CONDITIONS \ No newline at end of file
http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/caseless/README.md ---------------------------------------------------------------------- diff --git a/node_modules/caseless/README.md b/node_modules/caseless/README.md new file mode 100644 index 0000000..e5077a2 --- /dev/null +++ b/node_modules/caseless/README.md @@ -0,0 +1,45 @@ +## Caseless -- wrap an object to set and get property with caseless semantics but also preserve caseing. + +This library is incredibly useful when working with HTTP headers. It allows you to get/set/check for headers in a caseless manner while also preserving the caseing of headers the first time they are set. + +## Usage + +```javascript +var headers = {} + , c = caseless(headers) + ; +c.set('a-Header', 'asdf') +c.get('a-header') === 'asdf' +``` + +## has(key) + +Has takes a name and if it finds a matching header will return that header name with the preserved caseing it was set with. + +```javascript +c.has('a-header') === 'a-Header' +``` + +## set(key, value[, clobber=true]) + +Set is fairly straight forward except that if the header exists and clobber is disabled it will add `','+value` to the existing header. + +```javascript +c.set('a-Header', 'fdas') +c.set('a-HEADER', 'more', false) +c.get('a-header') === 'fdsa,more' +``` + +## swap(key) + +Swaps the casing of a header with the new one that is passed in. + +```javascript +var headers = {} + , c = caseless(headers) + ; +c.set('a-Header', 'fdas') +c.swap('a-HEADER') +c.has('a-header') === 'a-HEADER' +headers === {'a-HEADER': 'fdas'} +``` http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/caseless/index.js ---------------------------------------------------------------------- diff --git a/node_modules/caseless/index.js b/node_modules/caseless/index.js new file mode 100644 index 0000000..b194734 --- /dev/null +++ b/node_modules/caseless/index.js @@ -0,0 +1,67 @@ +function Caseless (dict) { + this.dict = dict || {} +} +Caseless.prototype.set = function (name, value, clobber) { + if (typeof name === 'object') { + for (var i in name) { + this.set(i, name[i], value) + } + } else { + if (typeof clobber === 'undefined') clobber = true + var has = this.has(name) + + if (!clobber && has) this.dict[has] = this.dict[has] + ',' + value + else this.dict[has || name] = value + return has + } +} +Caseless.prototype.has = function (name) { + var keys = Object.keys(this.dict) + , name = name.toLowerCase() + ; + for (var i=0;i<keys.length;i++) { + if (keys[i].toLowerCase() === name) return keys[i] + } + return false +} +Caseless.prototype.get = function (name) { + name = name.toLowerCase() + var result, _key + var headers = this.dict + Object.keys(headers).forEach(function (key) { + _key = key.toLowerCase() + if (name === _key) result = headers[key] + }) + return result +} +Caseless.prototype.swap = function (name) { + var has = this.has(name) + if (has === name) return + if (!has) throw new Error('There is no header than matches "'+name+'"') + this.dict[name] = this.dict[has] + delete this.dict[has] +} +Caseless.prototype.del = function (name) { + var has = this.has(name) + return delete this.dict[has || name] +} + +module.exports = function (dict) {return new Caseless(dict)} +module.exports.httpify = function (resp, headers) { + var c = new Caseless(headers) + resp.setHeader = function (key, value, clobber) { + if (typeof value === 'undefined') return + return c.set(key, value, clobber) + } + resp.hasHeader = function (key) { + return c.has(key) + } + resp.getHeader = function (key) { + return c.get(key) + } + resp.removeHeader = function (key) { + return c.del(key) + } + resp.headers = c.dict + return c +} http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/caseless/package.json ---------------------------------------------------------------------- diff --git a/node_modules/caseless/package.json b/node_modules/caseless/package.json new file mode 100644 index 0000000..93690a1 --- /dev/null +++ b/node_modules/caseless/package.json @@ -0,0 +1,101 @@ +{ + "_args": [ + [ + { + "raw": "caseless@~0.12.0", + "scope": null, + "escapedName": "caseless", + "name": "caseless", + "rawSpec": "~0.12.0", + "spec": ">=0.12.0 <0.13.0", + "type": "range" + }, + "/Users/yueguo/tmp/griffin-site/node_modules/request" + ] + ], + "_from": "caseless@>=0.12.0 <0.13.0", + "_id": "[email protected]", + "_inCache": true, + "_installable": true, + "_location": "/caseless", + "_nodeVersion": "6.9.2", + "_npmOperationalInternal": { + "host": "packages-12-west.internal.npmjs.com", + "tmp": "tmp/caseless-0.12.0.tgz_1485466648253_0.3714302028529346" + }, + "_npmUser": { + "name": "mikeal", + "email": "[email protected]" + }, + "_npmVersion": "3.10.9", + "_phantomChildren": {}, + "_requested": { + "raw": "caseless@~0.12.0", + "scope": null, + "escapedName": "caseless", + "name": "caseless", + "rawSpec": "~0.12.0", + "spec": ">=0.12.0 <0.13.0", + "type": "range" + }, + "_requiredBy": [ + "/request" + ], + "_resolved": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz";, + "_shasum": "1b681c21ff84033c826543090689420d187151dc", + "_shrinkwrap": null, + "_spec": "caseless@~0.12.0", + "_where": "/Users/yueguo/tmp/griffin-site/node_modules/request", + "author": { + "name": "Mikeal Rogers", + "email": "[email protected]" + }, + "bugs": { + "url": "https://github.com/mikeal/caseless/issues"; + }, + "dependencies": {}, + "description": "Caseless object set/get/has, very useful when working with HTTP headers.", + "devDependencies": { + "tape": "^2.10.2" + }, + "directories": {}, + "dist": { + "shasum": "1b681c21ff84033c826543090689420d187151dc", + "tarball": "https://registry.npmjs.org/caseless/-/caseless-0.12.0.tgz"; + }, + "gitHead": "af91df7878a8b53cf3dc2e9a086dc57ba8301649", + "homepage": "https://github.com/mikeal/caseless#readme";, + "keywords": [ + "headers", + "http", + "caseless" + ], + "license": "Apache-2.0", + "main": "index.js", + "maintainers": [ + { + "name": "mikeal", + "email": "[email protected]" + }, + { + "name": "nylen", + "email": "[email protected]" + }, + { + "name": "simov", + "email": "[email protected]" + } + ], + "name": "caseless", + "optionalDependencies": {}, + "readme": "ERROR: No README data found!", + "repository": { + "type": "git", + "url": "git+https://github.com/mikeal/caseless.git"; + }, + "scripts": { + "test": "node test.js" + }, + "test": "node test.js", + "version": "0.12.0" +} http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/caseless/test.js ---------------------------------------------------------------------- diff --git a/node_modules/caseless/test.js b/node_modules/caseless/test.js new file mode 100644 index 0000000..f55196c --- /dev/null +++ b/node_modules/caseless/test.js @@ -0,0 +1,67 @@ +var tape = require('tape') + , caseless = require('./') + ; + +tape('set get has', function (t) { + var headers = {} + , c = caseless(headers) + ; + t.plan(17) + c.set('a-Header', 'asdf') + t.equal(c.get('a-header'), 'asdf') + t.equal(c.has('a-header'), 'a-Header') + t.ok(!c.has('nothing')) + // old bug where we used the wrong regex + t.ok(!c.has('a-hea')) + c.set('a-header', 'fdsa') + t.equal(c.get('a-header'), 'fdsa') + t.equal(c.get('a-Header'), 'fdsa') + c.set('a-HEADER', 'more', false) + t.equal(c.get('a-header'), 'fdsa,more') + + t.deepEqual(headers, {'a-Header': 'fdsa,more'}) + c.swap('a-HEADER') + t.deepEqual(headers, {'a-HEADER': 'fdsa,more'}) + + c.set('deleteme', 'foobar') + t.ok(c.has('deleteme')) + t.ok(c.del('deleteme')) + t.notOk(c.has('deleteme')) + t.notOk(c.has('idonotexist')) + t.ok(c.del('idonotexist')) + + c.set('tva', 'test1') + c.set('tva-header', 'test2') + t.equal(c.has('tva'), 'tva') + t.notOk(c.has('header')) + + t.equal(c.get('tva'), 'test1') + +}) + +tape('swap', function (t) { + var headers = {} + , c = caseless(headers) + ; + t.plan(4) + // No Header to Swap. + t.throws(function () { + c.swap('content-type') + }) + // Set Header. + c.set('content-type', 'application/json') + // Swap Header With Itself. + c.swap('content-type') + // Does Not Delete Itself. + t.ok(c.has('content-type')) + // Swap Header With a Different Header. + c.swap('Content-Type') + // Still Has Header. + t.ok(c.has('Content-Type')) + // Delete Header. + c.del('Content-Type') + // No Header to Swap. + t.throws(function () { + c.swap('content-type') + }) +}) http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/chalk/index.js ---------------------------------------------------------------------- diff --git a/node_modules/chalk/index.js b/node_modules/chalk/index.js new file mode 100644 index 0000000..2d85a91 --- /dev/null +++ b/node_modules/chalk/index.js @@ -0,0 +1,116 @@ +'use strict'; +var escapeStringRegexp = require('escape-string-regexp'); +var ansiStyles = require('ansi-styles'); +var stripAnsi = require('strip-ansi'); +var hasAnsi = require('has-ansi'); +var supportsColor = require('supports-color'); +var defineProps = Object.defineProperties; +var isSimpleWindowsTerm = process.platform === 'win32' && !/^xterm/i.test(process.env.TERM); + +function Chalk(options) { + // detect mode if not set manually + this.enabled = !options || options.enabled === undefined ? supportsColor : options.enabled; +} + +// use bright blue on Windows as the normal blue color is illegible +if (isSimpleWindowsTerm) { + ansiStyles.blue.open = '\u001b[94m'; +} + +var styles = (function () { + var ret = {}; + + Object.keys(ansiStyles).forEach(function (key) { + ansiStyles[key].closeRe = new RegExp(escapeStringRegexp(ansiStyles[key].close), 'g'); + + ret[key] = { + get: function () { + return build.call(this, this._styles.concat(key)); + } + }; + }); + + return ret; +})(); + +var proto = defineProps(function chalk() {}, styles); + +function build(_styles) { + var builder = function () { + return applyStyle.apply(builder, arguments); + }; + + builder._styles = _styles; + builder.enabled = this.enabled; + // __proto__ is used because we must return a function, but there is + // no way to create a function with a different prototype. + /* eslint-disable no-proto */ + builder.__proto__ = proto; + + return builder; +} + +function applyStyle() { + // support varags, but simply cast to string in case there's only one arg + var args = arguments; + var argsLen = args.length; + var str = argsLen !== 0 && String(arguments[0]); + + if (argsLen > 1) { + // don't slice `arguments`, it prevents v8 optimizations + for (var a = 1; a < argsLen; a++) { + str += ' ' + args[a]; + } + } + + if (!this.enabled || !str) { + return str; + } + + var nestedStyles = this._styles; + var i = nestedStyles.length; + + // Turns out that on Windows dimmed gray text becomes invisible in cmd.exe, + // see https://github.com/chalk/chalk/issues/58 + // If we're on Windows and we're dealing with a gray color, temporarily make 'dim' a noop. + var originalDim = ansiStyles.dim.open; + if (isSimpleWindowsTerm && (nestedStyles.indexOf('gray') !== -1 || nestedStyles.indexOf('grey') !== -1)) { + ansiStyles.dim.open = ''; + } + + while (i--) { + var code = ansiStyles[nestedStyles[i]]; + + // Replace any instances already present with a re-opening code + // otherwise only the part of the string until said closing code + // will be colored, and the rest will simply be 'plain'. + str = code.open + str.replace(code.closeRe, code.open) + code.close; + } + + // Reset the original 'dim' if we changed it to work around the Windows dimmed gray issue. + ansiStyles.dim.open = originalDim; + + return str; +} + +function init() { + var ret = {}; + + Object.keys(styles).forEach(function (name) { + ret[name] = { + get: function () { + return build.call(this, [name]); + } + }; + }); + + return ret; +} + +defineProps(Chalk.prototype, init()); + +module.exports = new Chalk(); +module.exports.styles = ansiStyles; +module.exports.hasColor = hasAnsi; +module.exports.stripColor = stripAnsi; +module.exports.supportsColor = supportsColor; http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/chalk/license ---------------------------------------------------------------------- diff --git a/node_modules/chalk/license b/node_modules/chalk/license new file mode 100644 index 0000000..654d0bf --- /dev/null +++ b/node_modules/chalk/license @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) Sindre Sorhus <[email protected]> (sindresorhus.com) + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in +all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN +THE SOFTWARE. http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/chalk/package.json ---------------------------------------------------------------------- diff --git a/node_modules/chalk/package.json b/node_modules/chalk/package.json new file mode 100644 index 0000000..ed596a0 --- /dev/null +++ b/node_modules/chalk/package.json @@ -0,0 +1,144 @@ +{ + "_args": [ + [ + { + "raw": "chalk@^1.1.3", + "scope": null, + "escapedName": "chalk", + "name": "chalk", + "rawSpec": "^1.1.3", + "spec": ">=1.1.3 <2.0.0", + "type": "range" + }, + "/Users/yueguo/tmp/griffin-site/node_modules/hexo" + ] + ], + "_from": "chalk@>=1.1.3 <2.0.0", + "_id": "[email protected]", + "_inCache": true, + "_installable": true, + "_location": "/chalk", + "_nodeVersion": "0.10.32", + "_npmOperationalInternal": { + "host": "packages-12-west.internal.npmjs.com", + "tmp": "tmp/chalk-1.1.3.tgz_1459210604109_0.3892582862172276" + }, + "_npmUser": { + "name": "qix", + "email": "[email protected]" + }, + "_npmVersion": "2.14.2", + "_phantomChildren": {}, + "_requested": { + "raw": "chalk@^1.1.3", + "scope": null, + "escapedName": "chalk", + "name": "chalk", + "rawSpec": "^1.1.3", + "spec": ">=1.1.3 <2.0.0", + "type": "range" + }, + "_requiredBy": [ + "/hexo", + "/hexo-log", + "/hexo-server", + "/hexo/hexo-cli" + ], + "_resolved": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz";, + "_shasum": "a8115c55e4a702fe4d150abd3872822a7e09fc98", + "_shrinkwrap": null, + "_spec": "chalk@^1.1.3", + "_where": "/Users/yueguo/tmp/griffin-site/node_modules/hexo", + "bugs": { + "url": "https://github.com/chalk/chalk/issues"; + }, + "dependencies": { + "ansi-styles": "^2.2.1", + "escape-string-regexp": "^1.0.2", + "has-ansi": "^2.0.0", + "strip-ansi": "^3.0.0", + "supports-color": "^2.0.0" + }, + "description": "Terminal string styling done right. Much color.", + "devDependencies": { + "coveralls": "^2.11.2", + "matcha": "^0.6.0", + "mocha": "*", + "nyc": "^3.0.0", + "require-uncached": "^1.0.2", + "resolve-from": "^1.0.0", + "semver": "^4.3.3", + "xo": "*" + }, + "directories": {}, + "dist": { + "shasum": "a8115c55e4a702fe4d150abd3872822a7e09fc98", + "tarball": "https://registry.npmjs.org/chalk/-/chalk-1.1.3.tgz"; + }, + "engines": { + "node": ">=0.10.0" + }, + "files": [ + "index.js" + ], + "gitHead": "0d8d8c204eb87a4038219131ad4d8369c9f59d24", + "homepage": "https://github.com/chalk/chalk#readme";, + "keywords": [ + "color", + "colour", + "colors", + "terminal", + "console", + "cli", + "string", + "str", + "ansi", + "style", + "styles", + "tty", + "formatting", + "rgb", + "256", + "shell", + "xterm", + "log", + "logging", + "command-line", + "text" + ], + "license": "MIT", + "maintainers": [ + { + "name": "qix", + "email": "[email protected]" + }, + { + "name": "sindresorhus", + "email": "[email protected]" + }, + { + "name": "unicorn", + "email": "[email protected]" + } + ], + "name": "chalk", + "optionalDependencies": {}, + "readme": "ERROR: No README data found!", + "repository": { + "type": "git", + "url": "git+https://github.com/chalk/chalk.git"; + }, + "scripts": { + "bench": "matcha benchmark.js", + "coverage": "nyc npm test && nyc report", + "coveralls": "nyc npm test && nyc report --reporter=text-lcov | coveralls", + "test": "xo && mocha" + }, + "version": "1.1.3", + "xo": { + "envs": [ + "node", + "mocha" + ] + } +} http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/chalk/readme.md ---------------------------------------------------------------------- diff --git a/node_modules/chalk/readme.md b/node_modules/chalk/readme.md new file mode 100644 index 0000000..5cf111e --- /dev/null +++ b/node_modules/chalk/readme.md @@ -0,0 +1,213 @@ +<h1 align="center"> + <br> + <br> + <img width="360" src="https://cdn.rawgit.com/chalk/chalk/19935d6484811c5e468817f846b7b3d417d7bf4a/logo.svg"; alt="chalk"> + <br> + <br> + <br> +</h1> + +> Terminal string styling done right + +[](https://travis-ci.org/chalk/chalk) +[](https://coveralls.io/r/chalk/chalk?branch=master) +[](https://www.youtube.com/watch?v=9auOCbH5Ns4) + + +[colors.js](https://github.com/Marak/colors.js) used to be the most popular string styling module, but it has serious deficiencies like extending `String.prototype` which causes all kinds of [problems](https://github.com/yeoman/yo/issues/68). Although there are other ones, they either do too much or not enough. + +**Chalk is a clean and focused alternative.** + + + + +## Why + +- Highly performant +- Doesn't extend `String.prototype` +- Expressive API +- Ability to nest styles +- Clean and focused +- Auto-detects color support +- Actively maintained +- [Used by ~4500 modules](https://www.npmjs.com/browse/depended/chalk) as of July 15, 2015 + + +## Install + +``` +$ npm install --save chalk +``` + + +## Usage + +Chalk comes with an easy to use composable API where you just chain and nest the styles you want. + +```js +var chalk = require('chalk'); + +// style a string +chalk.blue('Hello world!'); + +// combine styled and normal strings +chalk.blue('Hello') + 'World' + chalk.red('!'); + +// compose multiple styles using the chainable API +chalk.blue.bgRed.bold('Hello world!'); + +// pass in multiple arguments +chalk.blue('Hello', 'World!', 'Foo', 'bar', 'biz', 'baz'); + +// nest styles +chalk.red('Hello', chalk.underline.bgBlue('world') + '!'); + +// nest styles of the same type even (color, underline, background) +chalk.green( + 'I am a green line ' + + chalk.blue.underline.bold('with a blue substring') + + ' that becomes green again!' +); +``` + +Easily define your own themes. + +```js +var chalk = require('chalk'); +var error = chalk.bold.red; +console.log(error('Error!')); +``` + +Take advantage of console.log [string substitution](http://nodejs.org/docs/latest/api/console.html#console_console_log_data). + +```js +var name = 'Sindre'; +console.log(chalk.green('Hello %s'), name); +//=> Hello Sindre +``` + + +## API + +### chalk.`<style>[.<style>...](string, [string...])` + +Example: `chalk.red.bold.underline('Hello', 'world');` + +Chain [styles](#styles) and call the last one as a method with a string argument. Order doesn't matter, and later styles take precedent in case of a conflict. This simply means that `Chalk.red.yellow.green` is equivalent to `Chalk.green`. + +Multiple arguments will be separated by space. + +### chalk.enabled + +Color support is automatically detected, but you can override it by setting the `enabled` property. You should however only do this in your own code as it applies globally to all chalk consumers. + +If you need to change this in a reusable module create a new instance: + +```js +var ctx = new chalk.constructor({enabled: false}); +``` + +### chalk.supportsColor + +Detect whether the terminal [supports color](https://github.com/chalk/supports-color). Used internally and handled for you, but exposed for convenience. + +Can be overridden by the user with the flags `--color` and `--no-color`. For situations where using `--color` is not possible, add an environment variable `FORCE_COLOR` with any value to force color. Trumps `--no-color`. + +### chalk.styles + +Exposes the styles as [ANSI escape codes](https://github.com/chalk/ansi-styles). + +Generally not useful, but you might need just the `.open` or `.close` escape code if you're mixing externally styled strings with your own. + +```js +var chalk = require('chalk'); + +console.log(chalk.styles.red); +//=> {open: '\u001b[31m', close: '\u001b[39m'} + +console.log(chalk.styles.red.open + 'Hello' + chalk.styles.red.close); +``` + +### chalk.hasColor(string) + +Check whether a string [has color](https://github.com/chalk/has-ansi). + +### chalk.stripColor(string) + +[Strip color](https://github.com/chalk/strip-ansi) from a string. + +Can be useful in combination with `.supportsColor` to strip color on externally styled text when it's not supported. + +Example: + +```js +var chalk = require('chalk'); +var styledString = getText(); + +if (!chalk.supportsColor) { + styledString = chalk.stripColor(styledString); +} +``` + + +## Styles + +### Modifiers + +- `reset` +- `bold` +- `dim` +- `italic` *(not widely supported)* +- `underline` +- `inverse` +- `hidden` +- `strikethrough` *(not widely supported)* + +### Colors + +- `black` +- `red` +- `green` +- `yellow` +- `blue` *(on Windows the bright version is used as normal blue is illegible)* +- `magenta` +- `cyan` +- `white` +- `gray` + +### Background colors + +- `bgBlack` +- `bgRed` +- `bgGreen` +- `bgYellow` +- `bgBlue` +- `bgMagenta` +- `bgCyan` +- `bgWhite` + + +## 256-colors + +Chalk does not support anything other than the base eight colors, which guarantees it will work on all terminals and systems. Some terminals, specifically `xterm` compliant ones, will support the full range of 8-bit colors. For this the lower level [ansi-256-colors](https://github.com/jbnicolai/ansi-256-colors) package can be used. + + +## Windows + +If you're on Windows, do yourself a favor and use [`cmder`](http://bliker.github.io/cmder/) instead of `cmd.exe`. + + +## Related + +- [chalk-cli](https://github.com/chalk/chalk-cli) - CLI for this module +- [ansi-styles](https://github.com/chalk/ansi-styles/) - ANSI escape codes for styling strings in the terminal +- [supports-color](https://github.com/chalk/supports-color/) - Detect whether a terminal supports color +- [strip-ansi](https://github.com/chalk/strip-ansi) - Strip ANSI escape codes +- [has-ansi](https://github.com/chalk/has-ansi) - Check if a string has ANSI escape codes +- [ansi-regex](https://github.com/chalk/ansi-regex) - Regular expression for matching ANSI escape codes +- [wrap-ansi](https://github.com/chalk/wrap-ansi) - Wordwrap a string with ANSI escape codes + + +## License + +MIT © [Sindre Sorhus](http://sindresorhus.com) http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/cheerio/History.md ---------------------------------------------------------------------- diff --git a/node_modules/cheerio/History.md b/node_modules/cheerio/History.md new file mode 100644 index 0000000..227fc17 --- /dev/null +++ b/node_modules/cheerio/History.md @@ -0,0 +1,556 @@ + +0.20.0 / 2016-02-01 +================== + + * Add coveralls badge, remove link to old report (Felix Böhm) + * Update lodash dependeny to 4.1.0 (leif.hanack) + * Fix PR #726 adding 'appendTo()' and 'prependTo()' (Delgan) + * Added appendTo and prependTo with tests #641 (digihaven) + * Fix #780 by changing options context in '.find()' (Felix Böhm) + * Add an unit test checking the query of child (Delgan) + * fix #667: attr({foo: null}) removes attribute foo, like attr('foo', null) (Ray Waldin) + * Include reference to dedicated "Loading" section (Mike Pennisi) + * Added load method to $ (alanev) + * update css-select to 1.2.0 (Felix Böhm) + * Fixing Grammatical Error (Dan Corman) + * Test against node v0.12 --> v4.2 (Jason Kurian) + * Correct output in example (Felix Böhm) + * Fix npm files filter (Bogdan Chadkin) + * Enable setting data on all elements in selection (Mike Pennisi) + * Reinstate `$.fn.toArray` (Mike Pennisi) + * update css-select to 1.1.0 (Thomas Shafer) + * Complete implementation of `wrap` (Mike Pennisi) + * Correct name of unit test (Mike Pennisi) + * Correct grammar in test titles (Mike Pennisi) + * Normalize whitespace (Mike Pennisi) + * Insert omitted assertion (Mike Pennisi) + * Update invocation of `children` (Mike Pennisi) + * Begin implementation of `wrap` method (Dandlezzz) + * Update Readme.md (Sven Slootweg) + * fix document's mistake in Readme.md (exoticknight) + * Add tests for setting text and html as non-strings (Ryc O'Chet) + * Fix for passing non-string values to .html or .text (Ryc O'Chet) + * use a selector to filter form elements (fb55) + * fix README.md typo (Yutian Li) + * README: fix spelling (Chris Rebert) + * Added support for options without a `value` attribute. Fixes #633 (Todd Wolfson) + * responding to pull request feedback - remove item() method and related tests (Ray Waldin) + * add length property and item method to object returned by prop('style'), plus tests (Ray Waldin) + * Added .prop method to readme (Artem Burtsev) + * Added .prop method (Artem Burtsev) + * Added Gitter badge (The Gitter Badger) + +0.19.0 / 2015-03-21 +================== + + * fixed allignment (fb55) + * added test case for malformed json in data attributes (fb55) + * fix: handle some extreme cases like `data-custom="{{templatevar}}"`. There is possibility error while parsing json . (Harish.K) + * Add missing optional selector doc for {prev,next}{All,Until} (Jérémie Astori) + * update to [email protected] (Felix Böhm) + * Document `Cheerio#serialzeArray` (Mike Pennisi) + * Fixed up `serializeArray()` and added multiple support (Todd Wolfson) + * Implement serializeArray() (Jarno Leppänen) + * recognize options in $.xml() (fb55) + * lib/static.js: text(): rm errant space before ++ (Chris Rebert) + * Do not expose internal `children` array (Mike Pennisi) + * Change lodash dependencies to ^3.1.0 (Samy Pessé) + * Update [email protected] (Samy Pessé) + * Updates Readme.md: .not(function (index, elem)) (Patrick Ward) + * update to [email protected] (fb55) + * Allow failures in Node.js v0.11 (Mike Pennisi) + * Added: Gittask badge (Matthew Mueller) + * Isolate prototypes of functions created via `load` (Mike Pennisi) + * Updates Readme.md: adds JS syntax highlighting (frankcash) + * #608 -- Add support for insertBefore/insertAfter syntax. Supports target types of: $, [$], selector (both single and multiple results) (Ben Cochran) + * Clone input nodes when inserting over a set (Mike Pennisi) + * Move unit test files (Mike Pennisi) + * remove unnecessarily tricky code (David Chambers) + * pass options to $.html in toString (fb55) + * add license info to package.json (Chris Rebert) + * xyz@~0.5.0 (David Chambers) + * Remove unofficial signature of `children` (Mike Pennisi) + * Fix bug in `css` method (Mike Pennisi) + * Correct bug in implementation of `Cheerio#val` (Mike Pennisi) + +0.18.0 / 2014-11-06 +================== + + * bump htmlparser2 dependency to ~3.8.1 (Chris Rebert) + * Correct unit test titles (Mike Pennisi) + * Correct behavior of `after` and `before` (Mike Pennisi) + * implement jQuery's .has() (Chris Rebert) + * Update repository url (haqii) + * attr() should return undefined or name for booleans (Raoul Millais) + * Update Readme.md (Ryan Breen) + * Implement `Cheerio#not` (Mike Pennisi) + * Clone nodes according to original parsing options (Mike Pennisi) + * fix lint error (David Chambers) + * Add explicit tests for DOM level 1 API (Mike Pennisi) + * Expose DOM level 1 API for Node-like objects (Mike Pennisi) + * Correct error in documentation (Mike Pennisi) + * Return a fully-qualified Function from `$.load` (Mike Pennisi) + * Update tests to avoid duck typing (Mike Pennisi) + * Alter "loaded" functions to produce true instances (Mike Pennisi) + * Organize tests for `cheerio.load` (Mike Pennisi) + * Complete `$.prototype.find` (Mike Pennisi) + * Use JSHint's `extends` option (Mike Pennisi) + * Remove aliases for exported methods (Mike Pennisi) + * Disallow unused variables (Mike Pennisi) + * Remove unused internal variables (Mike Pennisi) + * Remove unused variables from unit tests (Mike Pennisi) + * Remove unused API method references (Mike Pennisi) + * Move tests for `contains` method (Mike Pennisi) + * [email protected] (David Chambers) + * Created a wiki for companies using cheerio in production (Matthew Mueller) + * Implement `$.prototype.index` (Mike Pennisi) + * Implement `$.prototype.addBack` (Mike Pennisi) + * Added double quotes to radio attribute name to account for characters such as brackets (akant10) + * Update History.md (Gabriel Falkenberg) + * add 0.17.0 changelog (David Chambers) + * exit prepublish script if tag not found (David Chambers) + * alphabetize devDependencies (fb55) + * ignore coverage dir (fb55) + * submit coverage to coveralls (fb55) + * replace jscoverage with istanbul (fb55) + +0.17.0 / 2014-06-10 +================== + + * Fix bug in internal `uniqueSplice` function (Mike Pennisi) + * accept buffer argument to cheerio.load (David Chambers) + * Respect options on the element level (Alex Indigo) + * Change state definition to more readable (Artem Burtsev) + * added test (0xBADC0FFEE) + * add class only if doesn't exist (Artem Burtsev) + * Made it less insane. (Alex Indigo) + * Implement `Cheerio#add` (Mike Pennisi) + * Use "loaded" instance of Cheerio in unit tests (Mike Pennisi) + * Be more strict with object check. (Alex Indigo) + * Added options argument to .html() static method. (Alex Indigo) + * Fixed encoding mishaps. Adjusted tests. (Alex Indigo) + * use dom-serializer module (fb55) + * don't test on 0.8, don't ignore 0.11 (Felix Böhm) + * parse: rm unused variables (coderaiser) + * cheerio: rm unused variable (coderaiser) + * Fixed test (Avi Kohn) + * Added test (Avi Kohn) + * Changed == to === (Avi Kohn) + * Fixed a bug in removing type="hidden" attr (Avi Kohn) + * sorted (Alexey Raspopov) + * add `muted` attr to booleanAttributes (Alexey Raspopov) + * fixed context of `this` in .html (Felix Böhm) + * append new elements for each element in selection (fb55) + +0.16.0 / 2014-05-08 +================== + + * fix `make bench` (David Chambers) + * makefile: add release-* targets (David Chambers) + * alphabetize dependencies (David Chambers) + * Rewrite `data` internals with caching behavior (Mike Pennisi) + * Fence .val example as js (Kevin Sawicki) + * Fixed typos. Deleted trailing whitespace from test/render.js (Nattaphoom Ch) + * Fix manipulation APIs with removed elements (kpdecker) + * Perform manual string parsing for hasClass (kpdecker) + * Fix existing element removal (kpdecker) + * update render tests (Felix Böhm) + * fixed cheerio path (Felix Böhm) + * use `entities.escape` for attribute values (Felix Böhm) + * bump entities version (Felix Böhm) + * remove lowerCaseTags option from readme (Felix Böhm) + * added test case for .html in xmlMode (fb55) + * render xml in `html()` when `xmlMode: true` (fb55) + * use a map for booleanAttributes (fb55) + * update singleTags, use utils.isTag (fb55) + * update travis badge URL (Felix Böhm) + * use typeof instead of _.isString and _.isNumber (fb55) + * use Array.isArray instead of _.isArray (fb55) + * replace _.isFunction with typeof (fb55) + * removed unnecessary error message (fb55) + * decode entities in htmlparser2 (fb55) + * pass options object to CSSselect (fb55) + +0.15.0 / 2014-04-08 +================== + + * Update callbacks to pass element per docs (@kpdecker) + * preserve options (@fb55) + * Use SVG travis badge (@t3chnoboy) + * only use static requires (@fb55) + * Optimize manipulation methods (@kpdecker) + * Optimize add and remove class cases (@kpdecker) + * accept dom of DomHandler to cheerio.load (@nleush) + * added parentsUntil method (@finspin) + * Add performance optimization and bug fix `empty` method (@kpdecker) + +0.14.0 / 2014-04-01 +================== + + * call encodeXML and directly expose decodeHTML (@fb55) + * use latest htmlparser2 and entities versions (@fb55) + * Deprecate `$.fn.toArray` (@jugglinmike) + * Implement `$.fn.get` (@jugglinmike) + * .replaceWith now replaces all selected elements. (@xavi-) + * Correct arguments for 'replaceWith' callback (@jugglinmike) + * switch to lodash (@fb55) + * update to [email protected] (@fb55) + * Fix attr when $ collection contains text modules (@kpdecker) + * Update to latest version of expect.js (@jugglinmike) + * Remove nodes from their previous structures (@jugglinmike) + * Update render.js (@stevenvachon) + * CDATA test (@stevenvachon) + * only ever one child index for cdata (@stevenvachon) + * don't loop through cdata children array (@stevenvachon) + * proper rendering of CDATA (@stevenvachon) + * Add cheerio-only bench option (@kpdecker) + * Avoid delete operations (@kpdecker) + * Add independent html benchmark (@kpdecker) + * Cache tag check in render (@kpdecker) + * Simplify attribute rendering step (@kpdecker) + * Add html rendering bench case (@kpdecker) + * Remove unnecessary check from removeAttr (@kpdecker) + * Remove unnecessary encoding step for attrs (@kpdecker) + * Add test for removeAttr+attr on boolean attributes (@kpdecker) + * Add single element benchmark case (@kpdecker) + * Optimize filter with selector (@kpdecker) + * Fix passing context as dom node (@alfred-nsh) + * Fix bug in `nextUntil` (@jugglinmike) + * Fix bug in `nextAll` (@jugglinmike) + * Implement `selector` argument of `next` method (@jugglinmike) + * Fix bug in `prevUntil` (@jugglinmike) + * Implement `selector` argument of `prev` method (@jugglinmike) + * Fix bug in `prevAll` (@jugglinmike) + * Fix bug in `siblings` (@jugglinmike) + * Avoid unnecessary indexOf from toggleClass (@kpdecker) + * Use strict equality rather than falsy check in eq (@kpdecker) + * Add benchmark coverage for all $ APIs (@kpdecker) + * Optimize filter Cheerio intermediate creation (@kpdecker) + * Optimize siblings cheerio instance creation (@kpdecker) + * Optimize identity cases for first/last/eq (@kpdecker) + * Use domEach for traversal (@kpdecker) + * Inline children lookup in find (@kpdecker) + * Use domEach in data accessor (@kpdecker) + * Avoid cheerio creation in add/remove/toggleClass (@kpdecker) + * Implement getAttr local helper (@kpdecker) + +0.13.1 / 2014-01-07 +================== + + * Fix select with context in Cheerio function (@jugglinmike) + * Remove unecessary DOM maintenance logic (@jugglinmike) + * Deprecate support for node 0.6 + +0.13.0 / 2013-12-30 +================== + + * Remove "root" node (@jugglinmike) + * Fix bug in `prevAll`, `prev`, `nextAll`, `next`, `prevUntil`, `nextUntil` (@jugglinmike) + * Fix `replaceWith` method (@jugglinmike) + * added nextUntil() and prevUntil() (@finspin) + * Remove internal `connect` function (@jugglinmike) + * Rename `Cheerio#make` to document private status (@jugginmike) + * Remove extraneous call to `_.uniq` (@jugglinmike) + * Use CSSselect library directly (@jugglinmike) + * Run CI against Node v0.11 as an allowed failure (@jugginmike) + * Correct bug in `Cheerio#parents` (@jugglinmike) + * Implement `$.fn.end` (@jugginmike) + * Ignore colons inside of url(.*) when parsing css (@Meekohi) + * Introduce rudimentary benchmark suite (@jugglinmike) + * Update HtmlParser2 version (@jugglinmike) + * Correct inconsistency in `$.fn.map` (@jugglinmike) + * fixed traversing tests (@finspin) + * Simplify `make` method (@jugglinmike) + * Avoid shadowing instance methods from arrays (@jugglinmike) + +0.12.4 / 2013-11-12 +================== + + * Coerce JSON values returned by `data` (@jugglinmike) + * issue #284: when rendering HTML, use original data attributes (@Trott) + * Introduce JSHint for automated code linting (@jugglinmike) + * Prevent `find` from returning duplicate elements (@jugglinmike) + * Implement function signature of `replaceWith` (@jugglinmike) + * Implement function signature of `before` (@jugglinmike) + * Implement function signature of `after` (@jugglinmike) + * Implement function signature of `append`/`prepend` (@jugglinmike) + * Extend iteration methods to accept nodes (@jugglinmike) + * Improve `removeClass` (@jugglinmike) + * Complete function signature of `addClass` (@jugglinmike) + * Fix bug in `removeClass` (@jugglinmike) + * Improve contributing.md (@jugglinmike) + * Fix and document .css() (@jugglinmike) + +0.12.3 / 2013-10-04 +=================== + + * Add .toggleClass() function (@cyberthom) + * Add contributing guidelines (@jugglinmike) + * Fix bug in `siblings` (@jugglinmike) + * Correct the implementation `filter` and `is` (@jugglinmike) + * add .data() function (@andi-neck) + * add .css() (@yields) + * Implements contents() (@jlep) + +0.12.2 / 2013-09-04 +================== + + * Correct implementation of `$.fn.text` (@jugglinmike) + * Refactor Cheerio array creation (@jugglinmike) + * Extend manipulation methods to accept Arrays (@jugglinmike) + * support .attr(attributeName, function(index, attr)) (@xiaohwan) + +0.12.1 / 2013-07-30 +================== + + * Correct behavior of `Cheerio#parents` (@jugglinmike) + * Double quotes inside attributes kills HTML (@khoomeister) + * Making next({}) and prev({}) return empty object (@absentTelegraph) + * Implement $.parseHTML (@jugglinmike) + * Correct bug in jQuery.fn.closest (@jugglinmike) + * Correct behavior of $.fn.val on 'option' elements (@jugglinmike) + +0.12.0 / 2013-06-09 +=================== + + * Breaking Change: Changed context from parent to the actual passed one (@swissmanu) + * Fixed: jquery checkbox val behavior (@jhubble) + * Added: output xml with $.xml() (@Maciek416) + * Bumped: htmlparser2 to 3.1.1 + * Fixed: bug in attr(key, val) on empty objects (@farhadi) + * Added: prevAll, nextAll (@lessmind) + * Fixed: Safety check in parents and closest (@zero21xxx) + * Added: .is(sel) (@zero21xxx) + +0.11.0 / 2013-04-22 +================== + +* Added: .closest() (@jeremy-dentel) +* Added: .parents() (@zero21xxx) +* Added: .val() (@rschmukler & @leahciMic) +* Added: Travis support for node 0.10.0 (@jeremy-dentel) +* Fixed: .find() if no selector (@davidchambers) +* Fixed: Propagate syntax errors caused by invalid selectors (@davidchambers) + +0.10.8 / 2013-03-11 +================== + +* Add slice method (SBoudrias) + +0.10.7 / 2013-02-10 +================== + +* Code & doc cleanup (davidchambers) +* Fixed bug in filter (jugglinmike) + +0.10.6 / 2013-01-29 +================== + +* Added `$.contains(...)` (jugglinmike) +* formatting cleanup (davidchambers) +* Bug fix for `.children()` (jugglinmike & davidchambers) +* Remove global `render` bug (wvl) + +0.10.5 / 2012-12-18 +=================== + +* Fixed botched publish from 0.10.4 - changes should now be present + +0.10.4 / 2012-12-16 +================== + +* $.find should query descendants only (@jugglinmike) +* Tighter underscore dependency + +0.10.3 / 2012-11-18 +=================== + +* fixed outer html bug +* Updated documentation for $(...).html() and $.html() + +0.10.2 / 2012-11-17 +=================== + +* Added a toString() method (@bensheldon) +* use `_.each` and `_.map` to simplify cheerio namesakes (@davidchambers) +* Added filter() with tests and updated readme (@bensheldon & @davidchambers) +* Added spaces between attributes rewritten by removeClass (@jos3000) +* updated docs to remove reference to size method (@ironchefpython) +* removed HTML tidy/pretty print from cheerio + +0.10.1 / 2012-10-04 +=================== + +* Fixed regression, filtering with a context (#106) + +0.10.0 / 2012-09-24 +=================== + +* Greatly simplified and reorganized the library, reducing the loc by 30% +* Now supports mocha's test-coverage +* Deprecated self-closing tags (HTML5 doesn't require them) +* Fixed error thrown in removeClass(...) @robashton + +0.9.2 / 2012-08-10 +================== + +* added $(...).map(fn) +* manipulation: refactor `makeCheerioArray` +* make .removeClass() remove *all* occurrences (#64) + +0.9.1 / 2012-08-03 +================== + +* fixed bug causing options not to make it to the parser + +0.9.0 / 2012-07-24 +================== + +* Added node 8.x support +* Removed node 4.x support +* Add html(dom) support (@wvl) +* fixed xss vulnerabilities on .attr(), .text(), & .html() (@benatkin, @FB55) +* Rewrote tests into javascript, removing coffeescript dependency (@davidchambers) +* Tons of cleanup (@davidchambers) + +0.8.3 / 2012-06-12 +================== + +* Fixed minor package regression (closes #60) + +0.8.2 / 2012-06-11 +================== + +* Now fails gracefully in cases that involve special chars, which is inline with jQuery (closes #59) +* text() now decode special entities (closes #52) +* updated travis.yml to test node 4.x + +0.8.1 / 2012-06-02 +================== + +* fixed regression where if you created an element, it would update the root +* compatible with node 4.x (again) + +0.8.0 / 2012-05-27 +================== + +* Updated CSS parser to use FB55/CSSselect. Cheerio now supports most CSS3 psuedo selectors thanks to @FB55. +* ignoreWhitespace now on by default again. See #55 for context. +* Changed $(':root') to $.root(), cleaned up $.clone() +* Support for .eq(i) thanks to @alexbardas +* Removed support for node 0.4.x +* Fixed memory leak where package.json was continually loaded +* Tons more tests + +0.7.0 / 2012-04-08 +================== + +* Now testing with node v0.7.7 +* Added travis-ci integration +* Replaced should.js with expect.js. Browser testing to come +* Fixed spacing between attributes and their values +* Added HTML tidy/pretty print +* Exposed node-htmlparser2 parsing options +* Revert .replaceWith(...) to be consistent with jQuery + +0.6.2 / 2012-02-12 +================== + +* Fixed .replaceWith(...) regression + +0.6.1 / 2012-02-12 +================== + +* Added .first(), .last(), and .clone() commands. +* Option to parse using whitespace added to `.load`. +* Many bug fixes to make cheerio more aligned with jQuery. +* Added $(':root') to select the highest level element. + +Many thanks to the contributors that made this release happen: @ironchefpython and @siddMahen + +0.6.0 / 2012-02-07 +================== + +* *Important:* `$(...).html()` now returns inner HTML, which is in line with the jQuery spec +* `$.html()` returns the full HTML string. `$.html([cheerioObject])` will return the outer(selected element's tag) and inner HTML of that object +* Fixed bug that prevented HTML strings with depth (eg. `append('<ul><li><li></ul>')`) from getting `parent`, `next`, `prev` attributes. +* Halted [htmlparser2](https://github.com/FB55/node-htmlparser) at v2.2.2 until single attributes bug gets fixed. + +0.5.1 / 2012-02-05 +================== + +* Fixed minor regression: $(...).text(fn) would fail + +0.5.1 / 2012-02-05 +================== + +* Fixed regression: HTML pages with comments would fail + +0.5.0 / 2012-02-04 +================== + +* Transitioned from Coffeescript back to Javascript +* Parser now ignores whitespace +* Fixed issue with double slashes on self-enclosing tags +* Added boolean attributes to html rendering + +0.4.2 / 2012-01-16 +================== + +* Multiple selectors support: $('.apple, .orange'). Thanks @siddMahen! +* Update package.json to always use latest cheerio-soupselect +* Fix memory leak in index.js + +0.4.1 / 2011-12-19 +================== +* Minor packaging changes to allow `make test` to work from npm installation + +0.4.0 / 2011-12-19 +================== + +* Rewrote all unit tests as cheerio transitioned from vows -> mocha +* Internally, renderer.render -> render(...), parser.parse -> parse(...) +* Append, prepend, html, before, after all work with only text (no tags) +* Bugfix: Attributes can now be removed from script and style tags +* Added yield as a single tag +* Cheerio now compatible with node >=0.4.7 + +0.3.2 / 2011-12-1 +================= + +* Fixed $(...).text(...) to work with "root" element + +0.3.1 / 2011-11-25 +================== + +* Now relying on cheerio-soupselect instead of node-soupselect +* Removed all lingering htmlparser dependencies +* parser now returns parent "root" element. Root now never needs to be updated when there is multiple roots. This fixes ongoing issues with before(...), after(...) and other manipulation functions +* Added jQuery's $(...).replaceWith(...) + +0.3.0 / 2011-11-19 +================== + +* Now using htmlparser2 for parsing (2x speed increase, cleaner, actively developed) +* Added benchmark directory for future speed tests +* $('...').dom() was funky, so it was removed in favor of $('...').get(). $.dom() still works the same. +* $.root now correctly static across all instances of $ +* Added a screencast + +0.2.2 / 2011-11-9 +================= + +* Traversing will select `<script>` and `<style>` tags (Closes Issue: #8) +* .text(string) now working with empty elements (Closes Issue: #7) +* Fixed before(...) & after(...) again if there is no parent (Closes Issue: #2) + +0.2.1 / 2011-11-5 +================= + +* Fixed before(...) & after(...) if there is no parent (Closes Issue: #2) +* Comments now rendered correctly (Closes Issue: #5) + +< 0.2.0 / 2011-10-31 +==================== + +* Initial release (untracked development) http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/cheerio/Readme.md ---------------------------------------------------------------------- diff --git a/node_modules/cheerio/Readme.md b/node_modules/cheerio/Readme.md new file mode 100644 index 0000000..368738b --- /dev/null +++ b/node_modules/cheerio/Readme.md @@ -0,0 +1,1011 @@ +# cheerio [](http://travis-ci.org/cheeriojs/cheerio) [](https://gittask.com/cheeriojs/cheerio) [](https://coveralls.io/r/cheeriojs/cheerio) [](https://gitter.im/cheeriojs/cheerio?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge) + +Fast, flexible, and lean implementation of core jQuery designed specifically for the server. + +## Introduction +Teach your server HTML. + +```js +var cheerio = require('cheerio'), + $ = cheerio.load('<h2 class="title">Hello world</h2>'); + +$('h2.title').text('Hello there!'); +$('h2').addClass('welcome'); + +$.html(); +//=> <h2 class="title welcome">Hello there!</h2> +``` + +## Installation +`npm install cheerio` + +## Features +__❤ Familiar syntax:__ +Cheerio implements a subset of core jQuery. Cheerio removes all the DOM inconsistencies and browser cruft from the jQuery library, revealing its truly gorgeous API. + +__ϟ Blazingly fast:__ +Cheerio works with a very simple, consistent DOM model. As a result parsing, manipulating, and rendering are incredibly efficient. Preliminary end-to-end benchmarks suggest that cheerio is about __8x__ faster than JSDOM. + +__❁ Incredibly flexible:__ +Cheerio wraps around @FB55's forgiving [htmlparser2](https://github.com/fb55/htmlparser2/). Cheerio can parse nearly any HTML or XML document. + +## What about JSDOM? +I wrote cheerio because I found myself increasingly frustrated with JSDOM. For me, there were three main sticking points that I kept running into again and again: + +__• JSDOM's built-in parser is too strict:__ + JSDOM's bundled HTML parser cannot handle many popular sites out there today. + +__• JSDOM is too slow:__ +Parsing big websites with JSDOM has a noticeable delay. + +__• JSDOM feels too heavy:__ +The goal of JSDOM is to provide an identical DOM environment as what we see in the browser. I never really needed all this, I just wanted a simple, familiar way to do HTML manipulation. + +## When I would use JSDOM + +Cheerio will not solve all your problems. I would still use JSDOM if I needed to work in a browser-like environment on the server, particularly if I wanted to automate functional tests. + +## API + +### Markup example we'll be using: + +```html +<ul id="fruits"> + <li class="apple">Apple</li> + <li class="orange">Orange</li> + <li class="pear">Pear</li> +</ul> +``` + +This is the HTML markup we will be using in all of the API examples. + +### Loading +First you need to load in the HTML. This step in jQuery is implicit, since jQuery operates on the one, baked-in DOM. With Cheerio, we need to pass in the HTML document. + +This is the _preferred_ method: + +```js +var cheerio = require('cheerio'), + $ = cheerio.load('<ul id="fruits">...</ul>'); +``` + +Optionally, you can also load in the HTML by passing the string as the context: + +```js +$ = require('cheerio'); +$('ul', '<ul id="fruits">...</ul>'); +``` + +Or as the root: + +```js +$ = require('cheerio'); +$('li', 'ul', '<ul id="fruits">...</ul>'); +``` + +You can also pass an extra object to `.load()` if you need to modify any +of the default parsing options: + +```js +$ = cheerio.load('<ul id="fruits">...</ul>', { + normalizeWhitespace: true, + xmlMode: true +}); +``` + +These parsing options are taken directly from [htmlparser2](https://github.com/fb55/htmlparser2/wiki/Parser-options), therefore any options that can be used in `htmlparser2` are valid in cheerio as well. The default options are: + +```js +{ + normalizeWhitespace: false, + xmlMode: false, + decodeEntities: true +} + +``` + +For a full list of options and their effects, see [this](https://github.com/fb55/DomHandler) and +[htmlparser2's options](https://github.com/fb55/htmlparser2/wiki/Parser-options). + +### Selectors + +Cheerio's selector implementation is nearly identical to jQuery's, so the API is very similar. + +#### $( selector, [context], [root] ) +`selector` searches within the `context` scope which searches within the `root` scope. `selector` and `context` can be a string expression, DOM Element, array of DOM elements, or cheerio object. `root` is typically the HTML document string. + +This selector method is the starting point for traversing and manipulating the document. Like jQuery, it's the primary method for selecting elements in the document, but unlike jQuery it's built on top of the CSSSelect library, which implements most of the Sizzle selectors. + +```js +$('.apple', '#fruits').text() +//=> Apple + +$('ul .pear').attr('class') +//=> pear + +$('li[class=orange]').html() +//=> Orange +``` + +### Attributes +Methods for getting and modifying attributes. + +#### .attr( name, value ) +Method for getting and setting attributes. Gets the attribute value for only the first element in the matched set. If you set an attribute's value to `null`, you remove that attribute. You may also pass a `map` and `function` like jQuery. + +```js +$('ul').attr('id') +//=> fruits + +$('.apple').attr('id', 'favorite').html() +//=> <li class="apple" id="favorite">Apple</li> +``` + +> See http://api.jquery.com/attr/ for more information + +#### .prop( name, value ) +Method for getting and setting properties. Gets the property value for only the first element in the matched set. + +```js +$('input[type="checkbox"]').prop('checked') +//=> false + +$('input[type="checkbox"]').prop('checked', true).val() +//=> ok +``` + +> See http://api.jquery.com/prop/ for more information + +#### .data( name, value ) +Method for getting and setting data attributes. Gets or sets the data attribute value for only the first element in the matched set. + +```js +$('<div data-apple-color="red"></div>').data() +//=> { appleColor: 'red' } + +$('<div data-apple-color="red"></div>').data('apple-color') +//=> 'red' + +var apple = $('.apple').data('kind', 'mac') +apple.data('kind') +//=> 'mac' +``` + +> See http://api.jquery.com/data/ for more information + +#### .val( [value] ) +Method for getting and setting the value of input, select, and textarea. Note: Support for `map`, and `function` has not been added yet. + +```js +$('input[type="text"]').val() +//=> input_text + +$('input[type="text"]').val('test').html() +//=> <input type="text" value="test"/> +``` + +#### .removeAttr( name ) +Method for removing attributes by `name`. + +```js +$('.pear').removeAttr('class').html() +//=> <li>Pear</li> +``` + +#### .hasClass( className ) +Check to see if *any* of the matched elements have the given `className`. + +```js +$('.pear').hasClass('pear') +//=> true + +$('apple').hasClass('fruit') +//=> false + +$('li').hasClass('pear') +//=> true +``` + +#### .addClass( className ) +Adds class(es) to all of the matched elements. Also accepts a `function` like jQuery. + +```js +$('.pear').addClass('fruit').html() +//=> <li class="pear fruit">Pear</li> + +$('.apple').addClass('fruit red').html() +//=> <li class="apple fruit red">Apple</li> +``` + +> See http://api.jquery.com/addClass/ for more information. + +#### .removeClass( [className] ) +Removes one or more space-separated classes from the selected elements. If no `className` is defined, all classes will be removed. Also accepts a `function` like jQuery. + +```js +$('.pear').removeClass('pear').html() +//=> <li class="">Pear</li> + +$('.apple').addClass('red').removeClass().html() +//=> <li class="">Apple</li> +``` + +> See http://api.jquery.com/removeClass/ for more information. + +#### .toggleClass( className, [switch] ) +Add or remove class(es) from the matched elements, depending on either the class's presence or the value of the switch argument. Also accepts a `function` like jQuery. + +```js +$('.apple.green').toggleClass('fruit green red').html() +//=> <li class="apple fruit red">Apple</li> + +$('.apple.green').toggleClass('fruit green red', true).html() +//=> <li class="apple green fruit red">Apple</li> +``` + +> See http://api.jquery.com/toggleClass/ for more information. + +#### .is( selector ) +#### .is( element ) +#### .is( selection ) +#### .is( function(index) ) +Checks the current list of elements and returns `true` if _any_ of the elements match the selector. If using an element or Cheerio selection, returns `true` if _any_ of the elements match. If using a predicate function, the function is executed in the context of the selected element, so `this` refers to the current element. + +### Forms + +#### .serializeArray() + +Encode a set of form elements as an array of names and values. + +```js +$('<form><input name="foo" value="bar" /></form>').serializeArray() +//=> [ { name: 'foo', value: 'bar' } ] +``` + +### Traversing + +#### .find(selector) +#### .find(selection) +#### .find(node) +Get the descendants of each element in the current set of matched elements, filtered by a selector, jQuery object, or element. + +```js +$('#fruits').find('li').length +//=> 3 +$('#fruits').find($('.apple')).length +//=> 1 +``` + +#### .parent([selector]) +Get the parent of each element in the current set of matched elements, optionally filtered by a selector. + +```js +$('.pear').parent().attr('id') +//=> fruits +``` + +#### .parents([selector]) +Get a set of parents filtered by `selector` of each element in the current set of match elements. +```js +$('.orange').parents().length +// => 2 +$('.orange').parents('#fruits').length +// => 1 +``` + +#### .parentsUntil([selector][,filter]) +Get the ancestors of each element in the current set of matched elements, up to but not including the element matched by the selector, DOM node, or cheerio object. +```js +$('.orange').parentsUntil('#food').length +// => 1 +``` + +#### .closest(selector) +For each element in the set, get the first element that matches the selector by testing the element itself and traversing up through its ancestors in the DOM tree. + +```js +$('.orange').closest() +// => [] +$('.orange').closest('.apple') +// => [] +$('.orange').closest('li') +// => [<li class="orange">Orange</li>] +$('.orange').closest('#fruits') +// => [<ul id="fruits"> ... </ul>] +``` + +#### .next([selector]) +Gets the next sibling of the first selected element, optionally filtered by a selector. + +```js +$('.apple').next().hasClass('orange') +//=> true +``` + +#### .nextAll([selector]) +Gets all the following siblings of the first selected element, optionally filtered by a selector. + +```js +$('.apple').nextAll() +//=> [<li class="orange">Orange</li>, <li class="pear">Pear</li>] +$('.apple').nextAll('.orange') +//=> [<li class="orange">Orange</li>] +``` + +#### .nextUntil([selector], [filter]) +Gets all the following siblings up to but not including the element matched by the selector, optionally filtered by another selector. + +```js +$('.apple').nextUntil('.pear') +//=> [<li class="orange">Orange</li>] +``` + +#### .prev([selector]) +Gets the previous sibling of the first selected element optionally filtered by a selector. + +```js +$('.orange').prev().hasClass('apple') +//=> true +``` + +#### .prevAll([selector]) +Gets all the preceding siblings of the first selected element, optionally filtered by a selector. + +```js +$('.pear').prevAll() +//=> [<li class="orange">Orange</li>, <li class="apple">Apple</li>] +$('.pear').prevAll('.orange') +//=> [<li class="orange">Orange</li>] +``` + +#### .prevUntil([selector], [filter]) +Gets all the preceding siblings up to but not including the element matched by the selector, optionally filtered by another selector. + +```js +$('.pear').prevUntil('.apple') +//=> [<li class="orange">Orange</li>] +``` + +#### .slice( start, [end] ) +Gets the elements matching the specified range + +```js +$('li').slice(1).eq(0).text() +//=> 'Orange' + +$('li').slice(1, 2).length +//=> 1 +``` + +#### .siblings([selector]) +Gets the first selected element's siblings, excluding itself. + +```js +$('.pear').siblings().length +//=> 2 + +$('.pear').siblings('.orange').length +//=> 1 + +``` + +#### .children([selector]) +Gets the children of the first selected element. + +```js +$('#fruits').children().length +//=> 3 + +$('#fruits').children('.pear').text() +//=> Pear +``` + +#### .contents() +Gets the children of each element in the set of matched elements, including text and comment nodes. + +```js +$('#fruits').contents().length +//=> 3 +``` + +#### .each( function(index, element) ) +Iterates over a cheerio object, executing a function for each matched element. When the callback is fired, the function is fired in the context of the DOM element, so `this` refers to the current element, which is equivalent to the function parameter `element`. To break out of the `each` loop early, return with `false`. + +```js +var fruits = []; + +$('li').each(function(i, elem) { + fruits[i] = $(this).text(); +}); + +fruits.join(', '); +//=> Apple, Orange, Pear +``` + +#### .map( function(index, element) ) +Pass each element in the current matched set through a function, producing a new Cheerio object containing the return values. The function can return an individual data item or an array of data items to be inserted into the resulting set. If an array is returned, the elements inside the array are inserted into the set. If the function returns null or undefined, no element will be inserted. + +```js +$('li').map(function(i, el) { + // this === el + return $(this).text(); +}).get().join(' '); +//=> "apple orange pear" +``` + +#### .filter( selector ) <br /> .filter( selection ) <br /> .filter( element ) <br /> .filter( function(index) ) + +Iterates over a cheerio object, reducing the set of selector elements to those that match the selector or pass the function's test. When a Cheerio selection is specified, return only the elements contained in that selection. When an element is specified, return only that element (if it is contained in the original selection). If using the function method, the function is executed in the context of the selected element, so `this` refers to the current element. + +Selector: + +```js +$('li').filter('.orange').attr('class'); +//=> orange +``` + +Function: + +```js +$('li').filter(function(i, el) { + // this === el + return $(this).attr('class') === 'orange'; +}).attr('class') +//=> orange +``` + +#### .not( selector ) <br /> .not( selection ) <br /> .not( element ) <br /> .not( function(index, elem) ) + +Remove elements from the set of matched elements. Given a jQuery object that represents a set of DOM elements, the `.not()` method constructs a new jQuery object from a subset of the matching elements. The supplied selector is tested against each element; the elements that don't match the selector will be included in the result. The `.not()` method can take a function as its argument in the same way that `.filter()` does. Elements for which the function returns true are excluded from the filtered set; all other elements are included. + +Selector: + +```js +$('li').not('.apple').length; +//=> 2 +``` + +Function: + +```js +$('li').not(function(i, el) { + // this === el + return $(this).attr('class') === 'orange'; +}).length; +//=> 2 +``` + +#### .has( selector ) <br /> .has( element ) + +Filters the set of matched elements to only those which have the given DOM element as a descendant or which have a descendant that matches the given selector. Equivalent to `.filter(':has(selector)')`. + +Selector: + +```js +$('ul').has('.pear').attr('id'); +//=> fruits +``` + +Element: + +```js +$('ul').has($('.pear')[0]).attr('id'); +//=> fruits +``` + +#### .first() +Will select the first element of a cheerio object + +```js +$('#fruits').children().first().text() +//=> Apple +``` + +#### .last() +Will select the last element of a cheerio object + +```js +$('#fruits').children().last().text() +//=> Pear +``` + +#### .eq( i ) +Reduce the set of matched elements to the one at the specified index. Use `.eq(-i)` to count backwards from the last selected element. + +```js +$('li').eq(0).text() +//=> Apple + +$('li').eq(-1).text() +//=> Pear +``` + +#### .get( [i] ) + +Retrieve the DOM elements matched by the Cheerio object. If an index is specified, retrieve one of the elements matched by the Cheerio object: + +```js +$('li').get(0).tagName +//=> li +``` + +If no index is specified, retrieve all elements matched by the Cheerio object: + +```js +$('li').get().length +//=> 3 +``` + +#### .index() +#### .index( selector ) +#### .index( nodeOrSelection ) + +Search for a given element from among the matched elements. + +```js +$('.pear').index() +//=> 2 +$('.orange').index('li') +//=> 1 +$('.apple').index($('#fruit, li')) +//=> 1 +``` + +#### .end() +End the most recent filtering operation in the current chain and return the set of matched elements to its previous state. + +```js +$('li').eq(0).end().length +//=> 3 +``` + +#### .add( selector [, context] ) +#### .add( element ) +#### .add( elements ) +#### .add( html ) +#### .add( selection ) +Add elements to the set of matched elements. + +```js +$('.apple').add('.orange').length +//=> 2 +``` + +#### .addBack( [filter] ) + +Add the previous set of elements on the stack to the current set, optionally filtered by a selector. + +```js +$('li').eq(0).addBack('.orange').length +//=> 2 +``` + +### Manipulation +Methods for modifying the DOM structure. + +#### .append( content, [content, ...] ) +Inserts content as the *last* child of each of the selected elements. + +```js +$('ul').append('<li class="plum">Plum</li>') +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// <li class="plum">Plum</li> +// </ul> +``` + +#### .appendTo( target ) +Insert every element in the set of matched elements to the end of the target. + +```js +$('<li class="plum">Plum</li>').appendTo('#fruits') +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// <li class="plum">Plum</li> +// </ul> +``` + +#### .prepend( content, [content, ...] ) +Inserts content as the *first* child of each of the selected elements. + +```js +$('ul').prepend('<li class="plum">Plum</li>') +$.html() +//=> <ul id="fruits"> +// <li class="plum">Plum</li> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .prependTo( target ) +Insert every element in the set of matched elements to the beginning of the target. + +```js +$('<li class="plum">Plum</li>').prependTo('#fruits') +$.html() +//=> <ul id="fruits"> +// <li class="plum">Plum</li> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .after( content, [content, ...] ) +Insert content next to each element in the set of matched elements. + +```js +$('.apple').after('<li class="plum">Plum</li>') +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="plum">Plum</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .insertAfter( target ) +Insert every element in the set of matched elements after the target. + +```js +$('<li class="plum">Plum</li>').insertAfter('.apple') +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="plum">Plum</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .before( content, [content, ...] ) +Insert content previous to each element in the set of matched elements. + +```js +$('.apple').before('<li class="plum">Plum</li>') +$.html() +//=> <ul id="fruits"> +// <li class="plum">Plum</li> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .insertBefore( target ) +Insert every element in the set of matched elements before the target. + +```js +$('<li class="plum">Plum</li>').insertBefore('.apple') +$.html() +//=> <ul id="fruits"> +// <li class="plum">Plum</li> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +#### .remove( [selector] ) +Removes the set of matched elements from the DOM and all their children. `selector` filters the set of matched elements to be removed. + +```js +$('.pear').remove() +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// </ul> +``` + +#### .replaceWith( content ) +Replaces matched elements with `content`. + +```js +var plum = $('<li class="plum">Plum</li>') +$('.pear').replaceWith(plum) +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="plum">Plum</li> +// </ul> +``` + +#### .empty() +Empties an element, removing all its children. + +```js +$('ul').empty() +$.html() +//=> <ul id="fruits"></ul> +``` + +#### .html( [htmlString] ) +Gets an html content string from the first selected element. If `htmlString` is specified, each selected element's content is replaced by the new content. + +```js +$('.orange').html() +//=> Orange + +$('#fruits').html('<li class="mango">Mango</li>').html() +//=> <li class="mango">Mango</li> +``` + +#### .text( [textString] ) +Get the combined text contents of each element in the set of matched elements, including their descendants.. If `textString` is specified, each selected element's content is replaced by the new text content. + +```js +$('.orange').text() +//=> Orange + +$('ul').text() +//=> Apple +// Orange +// Pear +``` + +#### .wrap( content ) +The .wrap() function can take any string or object that could be passed to the $() factory function to specify a DOM structure. This structure may be nested several levels deep, but should contain only one inmost element. A copy of this structure will be wrapped around each of the elements in the set of matched elements. This method returns the original set of elements for chaining purposes. + +```js +var redFruit = $('<div class="red-fruit"></div>') +$('.apple').wrap(redFruit) + +//=> <ul id="fruits"> +// <div class="red-fruit"> +// <li class="apple">Apple</li> +// </div> +// <li class="orange">Orange</li> +// <li class="plum">Plum</li> +// </ul> + +var healthy = $('<div class="healthy"></div>') +$('li').wrap(healthy) + +//=> <ul id="fruits"> +// <div class="healthy"> +// <li class="apple">Apple</li> +// </div> +// <div class="healthy"> +// <li class="orange">Orange</li> +// </div> +// <div class="healthy"> +// <li class="plum">Plum</li> +// </div> +// </ul> +``` + +#### .css( [propertName] ) <br /> .css( [ propertyNames] ) <br /> .css( [propertyName], [value] ) <br /> .css( [propertName], [function] ) <br /> .css( [properties] ) + +Get the value of a style property for the first element in the set of matched elements or set one or more CSS properties for every matched element. + +### Rendering +When you're ready to render the document, you can use the `html` utility function: + +```js +$.html() +//=> <ul id="fruits"> +// <li class="apple">Apple</li> +// <li class="orange">Orange</li> +// <li class="pear">Pear</li> +// </ul> +``` + +If you want to return the outerHTML you can use `$.html(selector)`: + +```js +$.html('.pear') +//=> <li class="pear">Pear</li> +``` + +By default, `html` will leave some tags open. Sometimes you may instead want to render a valid XML document. For example, you might parse the following XML snippet: + +```xml +$ = cheerio.load('<media:thumbnail url="http://www.foo.com/keyframe.jpg"; width="75" height="50" time="12:05:01.123"/>'); +``` + +... and later want to render to XML. To do this, you can use the 'xml' utility function: + +```js +$.xml() +//=> <media:thumbnail url="http://www.foo.com/keyframe.jpg"; width="75" height="50" time="12:05:01.123"/> +``` + + +### Miscellaneous +DOM element methods that don't fit anywhere else + +#### .toArray() +Retrieve all the DOM elements contained in the jQuery set as an array. + +```js +$('li').toArray() +//=> [ {...}, {...}, {...} ] +``` + +#### .clone() #### +Clone the cheerio object. + +```js +var moreFruit = $('#fruits').clone() +``` + +### Utilities + +#### $.root + +Sometimes you need to work with the top-level root element. To query it, you can use `$.root()`. + +```js +$.root().append('<ul id="vegetables"></ul>').html(); +//=> <ul id="fruits">...</ul><ul id="vegetables"></ul> +``` + +#### $.contains( container, contained ) +Checks to see if the `contained` DOM element is a descendant of the `container` DOM element. + +#### $.parseHTML( data [, context ] [, keepScripts ] ) +Parses a string into an array of DOM nodes. The `context` argument has no meaning for Cheerio, but it is maintained for API compatability. + +#### $.load( html[, options ] ) +Load in the HTML. (See the previous section titled "Loading" for more information.) + +### Plugins + +Once you have loaded a document, you may extend the prototype or the equivalent `fn` property with custom plugin methods: + +```js +var $ = cheerio.load('<html><body>Hello, <b>world</b>!</body></html>'); +$.prototype.logHtml = function() { + console.log(this.html()); +}; + +$('body').logHtml(); // logs "Hello, <b>world</b>!" to the console +``` + +### The "DOM Node" object + +Cheerio collections are made up of objects that bear some resemblence to [browser-based DOM nodes](https://developer.mozilla.org/en-US/docs/Web/API/Node). You can expect them to define the following properties: + +- `tagName` +- `parentNode` +- `previousSibling` +- `nextSibling` +- `nodeValue` +- `firstChild` +- `childNodes` +- `lastChild` + +## Screencasts + +http://vimeo.com/31950192 + +> This video tutorial is a follow-up to Nettut's "How to Scrape Web Pages with Node.js and jQuery", using cheerio instead of JSDOM + jQuery. This video shows how easy it is to use cheerio and how much faster cheerio is than JSDOM + jQuery. + +## Testing + +To run the test suite, download the repository, then within the cheerio directory, run: + +```shell +make setup +make test +``` + +This will download the development packages and run the test suite. + +## Contributors + +These are some of the contributors that have made cheerio possible: + +``` +project : cheerio + repo age : 2 years, 6 months + active : 285 days + commits : 762 + files : 36 + authors : + 293 Matt Mueller 38.5% + 133 Matthew Mueller 17.5% + 92 Mike Pennisi 12.1% + 54 David Chambers 7.1% + 30 kpdecker 3.9% + 19 Felix Böhm 2.5% + 17 fb55 2.2% + 15 Siddharth Mahendraker 2.0% + 11 Adam Bretz 1.4% + 8 Nazar Leush 1.0% + 7 ironchefpython 0.9% + 6 Jarno Leppänen 0.8% + 5 Ben Sheldon 0.7% + 5 Jos Shepherd 0.7% + 5 Ryan Schmukler 0.7% + 5 Steven Vachon 0.7% + 4 Maciej Adwent 0.5% + 4 Amir Abu Shareb 0.5% + 3 [email protected] 0.4% + 3 Andi Neck 0.4% + 2 steve 0.3% + 2 alexbardas 0.3% + 2 finspin 0.3% + 2 Ali Farhadi 0.3% + 2 Chris Khoo 0.3% + 2 Rob Ashton 0.3% + 2 Thomas Heymann 0.3% + 2 Jaro Spisak 0.3% + 2 Dan Dascalescu 0.3% + 2 Torstein Thune 0.3% + 2 Wayne Larsen 0.3% + 1 Timm Preetz 0.1% + 1 Xavi 0.1% + 1 Alex Shaindlin 0.1% + 1 mattym 0.1% + 1 Felix Böhm 0.1% + 1 Farid Neshat 0.1% + 1 Dmitry Mazuro 0.1% + 1 Jeremy Hubble 0.1% + 1 nevermind 0.1% + 1 Manuel Alabor 0.1% + 1 Matt Liegey 0.1% + 1 Chris O'Hara 0.1% + 1 Michael Holroyd 0.1% + 1 Michiel De Mey 0.1% + 1 Ben Atkin 0.1% + 1 Rich Trott 0.1% + 1 Rob "Hurricane" Ashton 0.1% + 1 Robin Gloster 0.1% + 1 Simon Boudrias 0.1% + 1 Sindre Sorhus 0.1% + 1 xiaohwan 0.1% +``` + +## Cheerio in the real world + +Are you using cheerio in production? Add it to the [wiki](https://github.com/cheeriojs/cheerio/wiki/Cheerio-in-Production)! + +## Special Thanks + +This library stands on the shoulders of some incredible developers. A special thanks to: + +__• @FB55 for node-htmlparser2 & CSSSelect:__ +Felix has a knack for writing speedy parsing engines. He completely re-wrote both @tautologistic's `node-htmlparser` and @harry's `node-soupselect` from the ground up, making both of them much faster and more flexible. Cheerio would not be possible without his foundational work + +__• @jQuery team for jQuery:__ +The core API is the best of its class and despite dealing with all the browser inconsistencies the code base is extremely clean and easy to follow. Much of cheerio's implementation and documentation is from jQuery. Thanks guys. + +__• @visionmedia:__ +The style, the structure, the open-source"-ness" of this library comes from studying TJ's style and using many of his libraries. This dude consistently pumps out high-quality libraries and has always been more than willing to help or answer questions. You rock TJ. + +## License + +(The MIT License) + +Copyright (c) 2012 Matt Mueller <[email protected]> + +Permission is hereby granted, free of charge, to any person obtaining +a copy of this software and associated documentation files (the +'Software'), to deal in the Software without restriction, including +without limitation the rights to use, copy, modify, merge, publish, +distribute, sublicense, and/or sell copies of the Software, and to +permit persons to whom the Software is furnished to do so, subject to +the following conditions: + +The above copyright notice and this permission notice shall be +included in all copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND, +EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF +MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. +IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY +CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, +TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE +SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. http://git-wip-us.apache.org/repos/asf/incubator-griffin-site/blob/4f8fa326/node_modules/cheerio/index.js ---------------------------------------------------------------------- diff --git a/node_modules/cheerio/index.js b/node_modules/cheerio/index.js new file mode 100644 index 0000000..3a040a2 --- /dev/null +++ b/node_modules/cheerio/index.js @@ -0,0 +1,11 @@ +/** + * Export cheerio (with ) + */ + +exports = module.exports = require('./lib/cheerio'); + +/* + Export the version +*/ + +exports.version = require('./package').version;
![https://cdn.rawgit.com/chalk/chalk/19935d6484811c5e468817f846b7b3d417d7bf4a/logo.svg"](https://cdn.rawgit.com/chalk/chalk/19935d6484811c5e468817f846b7b3d417d7bf4a/logo.svg"){kind=link}
![http://www.foo.com/keyframe.jpg"](http://www.foo.com/keyframe.jpg"){kind=link}