tck-lambdas 0.1.5 → 0.1.6

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/examples/varargs.js

@@ -0,0 +1,6 @@
+var verror = require('../lib/verror');
+
+var opname = 'read';
+var err = new verror.VError('"%s" operation failed', opname);
+console.log(err.message);
+console.log(err.stack);

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/examples/verror.js

@@ -0,0 +1,13 @@
+var mod_fs = require('fs');
+var mod_verror = require('../lib/verror');
+
+var filename = '/nonexistent';
+
+mod_fs.stat(filename, function (err1) {
+	var err2 = new mod_verror.VError(err1, 'failed to stat "%s"', filename);
+
+	/* The following would normally be higher up the stack. */
+	var err3 = new mod_verror.VError(err2, 'failed to handle request');
+	console.log(err3.message);
+	console.log(err3.stack);
+});

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/examples/werror.js

@@ -0,0 +1,14 @@
+var mod_fs = require('fs');
+var mod_verror = require('../lib/verror');
+
+var filename = '/nonexistent';
+
+mod_fs.stat(filename, function (err1) {
+	var err2 = new mod_verror.WError(err1, 'failed to stat "%s"', filename);
+
+	/* The following would normally be higher up the stack. */
+	var err3 = new mod_verror.WError(err2, 'failed to handle request');
+	console.log(err3.message);
+	console.log(err3.toString());
+	console.log(err3.stack);
+});

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/jsl.node.conf

@@ -0,0 +1,139 @@
+#
+# Configuration File for JavaScript Lint 
+#
+# This configuration file can be used to lint a collection of scripts, or to enable
+# or disable warnings for scripts that are linted via the command line.
+#
+
+### Warnings
+# Enable or disable warnings based on requirements.
+# Use "+WarningName" to display or "-WarningName" to suppress.
+#
++ambiguous_else_stmt          # the else statement could be matched with one of multiple if statements (use curly braces to indicate intent
++ambiguous_nested_stmt        # block statements containing block statements should use curly braces to resolve ambiguity
++ambiguous_newline            # unexpected end of line; it is ambiguous whether these lines are part of the same statement
++anon_no_return_value         # anonymous function does not always return value
++assign_to_function_call      # assignment to a function call
+-block_without_braces         # block statement without curly braces
++comma_separated_stmts        # multiple statements separated by commas (use semicolons?)
++comparison_type_conv         # comparisons against null, 0, true, false, or an empty string allowing implicit type conversion (use === or !==)
++default_not_at_end           # the default case is not at the end of the switch statement
++dup_option_explicit          # duplicate "option explicit" control comment
++duplicate_case_in_switch     # duplicate case in switch statement
++duplicate_formal             # duplicate formal argument {name}
++empty_statement              # empty statement or extra semicolon
++identifier_hides_another     # identifer {name} hides an identifier in a parent scope
+-inc_dec_within_stmt          # increment (++) and decrement (--) operators used as part of greater statement
++incorrect_version            # Expected /*jsl:content-type*/ control comment. The script was parsed with the wrong version.
++invalid_fallthru             # unexpected "fallthru" control comment
++invalid_pass                 # unexpected "pass" control comment
++jsl_cc_not_understood        # couldn't understand control comment using /*jsl:keyword*/ syntax
++leading_decimal_point        # leading decimal point may indicate a number or an object member
++legacy_cc_not_understood     # couldn't understand control comment using /*@keyword@*/ syntax
++meaningless_block            # meaningless block; curly braces have no impact
++mismatch_ctrl_comments       # mismatched control comment; "ignore" and "end" control comments must have a one-to-one correspondence
++misplaced_regex              # regular expressions should be preceded by a left parenthesis, assignment, colon, or comma
++missing_break                # missing break statement
++missing_break_for_last_case  # missing break statement for last case in switch
++missing_default_case         # missing default case in switch statement
++missing_option_explicit      # the "option explicit" control comment is missing
++missing_semicolon            # missing semicolon
++missing_semicolon_for_lambda # missing semicolon for lambda assignment
++multiple_plus_minus          # unknown order of operations for successive plus (e.g. x+++y) or minus (e.g. x---y) signs
++nested_comment               # nested comment
++no_return_value              # function {name} does not always return a value
++octal_number                 # leading zeros make an octal number
++parseint_missing_radix       # parseInt missing radix parameter
++partial_option_explicit      # the "option explicit" control comment, if used, must be in the first script tag
++redeclared_var               # redeclaration of {name}
++trailing_comma_in_array      # extra comma is not recommended in array initializers
++trailing_decimal_point       # trailing decimal point may indicate a number or an object member
++undeclared_identifier        # undeclared identifier: {name}
++unreachable_code             # unreachable code
+-unreferenced_argument        # argument declared but never referenced: {name}
+-unreferenced_function        # function is declared but never referenced: {name}
++unreferenced_variable        # variable is declared but never referenced: {name}
++unsupported_version          # JavaScript {version} is not supported
++use_of_label                 # use of label
++useless_assign               # useless assignment
++useless_comparison           # useless comparison; comparing identical expressions
+-useless_quotes               # the quotation marks are unnecessary
++useless_void                 # use of the void type may be unnecessary (void is always undefined)
++var_hides_arg                # variable {name} hides argument
++want_assign_or_call          # expected an assignment or function call
++with_statement               # with statement hides undeclared variables; use temporary variable instead
+
+
+### Output format
+# Customize the format of the error message.
+#    __FILE__ indicates current file path
+#    __FILENAME__ indicates current file name
+#    __LINE__ indicates current line
+#    __COL__ indicates current column
+#    __ERROR__ indicates error message (__ERROR_PREFIX__: __ERROR_MSG__)
+#    __ERROR_NAME__ indicates error name (used in configuration file)
+#    __ERROR_PREFIX__ indicates error prefix
+#    __ERROR_MSG__ indicates error message
+#
+# For machine-friendly output, the output format can be prefixed with
+# "encode:". If specified, all items will be encoded with C-slashes.
+#
+# Visual Studio syntax (default):
++output-format __FILE__(__LINE__): __ERROR__
+# Alternative syntax:
+#+output-format __FILE__:__LINE__: __ERROR__
+
+
+### Context
+# Show the in-line position of the error.
+# Use "+context" to display or "-context" to suppress.
+#
++context
+
+
+### Control Comments
+# Both JavaScript Lint and the JScript interpreter confuse each other with the syntax for
+# the /*@keyword@*/ control comments and JScript conditional comments. (The latter is
+# enabled in JScript with @cc_on@). The /*jsl:keyword*/ syntax is preferred for this reason,
+# although legacy control comments are enabled by default for backward compatibility.
+#
+-legacy_control_comments
+
+
+### Defining identifiers
+# By default, "option explicit" is enabled on a per-file basis.
+# To enable this for all files, use "+always_use_option_explicit"
+-always_use_option_explicit
+
+# Define certain identifiers of which the lint is not aware.
+# (Use this in conjunction with the "undeclared identifier" warning.)
+#
+# Common uses for webpages might be:
++define __dirname
++define clearInterval
++define clearTimeout
++define console
++define exports
++define global
++define process
++define require
++define setInterval
++define setTimeout
++define Buffer
++define JSON
++define Math
++define __dirname
++define __filename
+
+### JavaScript Version
+# To change the default JavaScript version:
+#+default-type text/javascript;version=1.5
+#+default-type text/javascript;e4x=1
+
+### Files
+# Specify which files to lint
+# Use "+recurse" to enable recursion (disabled by default).
+# To add a set of files, use "+process FileName", "+process Folder\Path\*.js",
+# or "+process Folder\Path\*.htm".
+#
+

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/lib/verror.js

@@ -0,0 +1,157 @@
+/*
+ * verror.js: richer JavaScript errors
+ */
+
+var mod_assert = require('assert');
+var mod_util = require('util');
+
+var mod_extsprintf = require('extsprintf');
+
+/*
+ * Public interface
+ */
+exports.VError = VError;
+exports.WError = WError;
+exports.MultiError = MultiError;
+
+/*
+ * Like JavaScript's built-in Error class, but supports a "cause" argument and a
+ * printf-style message.  The cause argument can be null.
+ */
+function VError(options)
+{
+	var args, causedBy, ctor, tailmsg;
+
+	if (options instanceof Error || typeof (options) === 'object') {
+		args = Array.prototype.slice.call(arguments, 1);
+	} else {
+		args = Array.prototype.slice.call(arguments, 0);
+		options = undefined;
+	}
+
+	tailmsg = args.length > 0 ?
+	    mod_extsprintf.sprintf.apply(null, args) : '';
+	this.jse_shortmsg = tailmsg;
+	this.jse_summary = tailmsg;
+
+	if (options) {
+		causedBy = options.cause;
+
+		if (!causedBy || !(options.cause instanceof Error))
+			causedBy = options;
+
+		if (causedBy && (causedBy instanceof Error)) {
+			this.jse_cause = causedBy;
+			this.jse_summary += ': ' + causedBy.message;
+		}
+	}
+
+	this.message = this.jse_summary;
+	Error.call(this, this.jse_summary);
+
+	if (Error.captureStackTrace) {
+		ctor = options ? options.constructorOpt : undefined;
+		ctor = ctor || arguments.callee;
+		Error.captureStackTrace(this, ctor);
+	}
+}
+
+mod_util.inherits(VError, Error);
+VError.prototype.name = 'VError';
+
+VError.prototype.toString = function ve_toString()
+{
+	var str = (this.hasOwnProperty('name') && this.name ||
+		this.constructor.name || this.constructor.prototype.name);
+	if (this.message)
+		str += ': ' + this.message;
+
+	return (str);
+};
+
+VError.prototype.cause = function ve_cause()
+{
+	return (this.jse_cause);
+};
+
+
+/*
+ * Represents a collection of errors for the purpose of consumers that generally
+ * only deal with one error.  Callers can extract the individual errors
+ * contained in this object, but may also just treat it as a normal single
+ * error, in which case a summary message will be printed.
+ */
+function MultiError(errors)
+{
+	mod_assert.ok(errors.length > 0);
+	this.ase_errors = errors;
+
+	VError.call(this, errors[0], 'first of %d error%s',
+	    errors.length, errors.length == 1 ? '' : 's');
+}
+
+mod_util.inherits(MultiError, VError);
+
+
+
+/*
+ * Like JavaScript's built-in Error class, but supports a "cause" argument which
+ * is wrapped, not "folded in" as with VError.	Accepts a printf-style message.
+ * The cause argument can be null.
+ */
+function WError(options)
+{
+	Error.call(this);
+
+	var args, cause, ctor;
+	if (typeof (options) === 'object') {
+		args = Array.prototype.slice.call(arguments, 1);
+	} else {
+		args = Array.prototype.slice.call(arguments, 0);
+		options = undefined;
+	}
+
+	if (args.length > 0) {
+		this.message = mod_extsprintf.sprintf.apply(null, args);
+	} else {
+		this.message = '';
+	}
+
+	if (options) {
+		if (options instanceof Error) {
+			cause = options;
+		} else {
+			cause = options.cause;
+			ctor = options.constructorOpt;
+		}
+	}
+
+	Error.captureStackTrace(this, ctor || this.constructor);
+	if (cause)
+		this.cause(cause);
+
+}
+
+mod_util.inherits(WError, Error);
+WError.prototype.name = 'WError';
+
+
+WError.prototype.toString = function we_toString()
+{
+	var str = (this.hasOwnProperty('name') && this.name ||
+		this.constructor.name || this.constructor.prototype.name);
+	if (this.message)
+		str += ': ' + this.message;
+	if (this.we_cause && this.we_cause.message)
+		str += '; caused by ' + this.we_cause.toString();
+
+	return (str);
+};
+
+WError.prototype.cause = function we_cause(c)
+{
+	if (c instanceof Error)
+		this.we_cause = c;
+
+	return (this.we_cause);
+};

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "verror",
+  "version": "1.3.6",
+  "description": "richer JavaScript errors",
+  "main": "./lib/verror.js",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/davepacheco/node-verror.git"
+  },
+  "dependencies": {
+    "extsprintf": "1.0.2"
+  },
+  "engines": [
+    "node >=0.6.0"
+  ],
+  "scripts": {
+    "test": "make test"
+  },
+  "_id": "verror@1.3.6",
+  "dist": {
+    "shasum": "cff5df12946d297d2baaefaa2689e25be01c005c",
+    "tarball": "https://registry.npmjs.org/verror/-/verror-1.3.6.tgz"
+  },
+  "_npmVersion": "1.1.65",
+  "_npmUser": {
+    "name": "dap",
+    "email": "dap@cs.brown.edu"
+  },
+  "maintainers": [
+    {
+      "name": "dap",
+      "email": "dap@cs.brown.edu"
+    }
+  ],
+  "directories": {},
+  "_shasum": "cff5df12946d297d2baaefaa2689e25be01c005c",
+  "_from": "verror@1.3.6",
+  "_resolved": "https://registry.npmjs.org/verror/-/verror-1.3.6.tgz",
+  "bugs": {
+    "url": "https://github.com/davepacheco/node-verror/issues"
+  },
+  "readme": "ERROR: No README data found!"
+}

data/lib/tck/lambdas/chistacojs/source/node_modules/request/node_modules/http-signature/node_modules/jsprim/node_modules/verror/tests/tst.inherit.js

@@ -0,0 +1,100 @@
+/*
+ * tst.inherit.js: test that inheriting from VError and WError work as expected.
+ */
+
+var mod_assert = require('assert');
+var mod_util = require('util');
+
+var mod_verror = require('../lib/verror');
+
+var VError = mod_verror.VError;
+var WError = mod_verror.WError;
+var err, suberr;
+
+function VErrorChild()
+{
+	VError.apply(this, Array.prototype.slice.call(arguments));
+}
+
+mod_util.inherits(VErrorChild, VError);
+VErrorChild.prototype.name = 'VErrorChild';
+
+
+function WErrorChild()
+{
+	WError.apply(this, Array.prototype.slice.call(arguments));
+}
+
+mod_util.inherits(WErrorChild, WError);
+WErrorChild.prototype.name = 'WErrorChild';
+
+
+suberr = new Error('root cause');
+err = new VErrorChild(suberr, 'top');
+mod_assert.ok(err instanceof Error);
+mod_assert.ok(err instanceof VError);
+mod_assert.ok(err instanceof VErrorChild);
+mod_assert.equal(err.cause(), suberr);
+mod_assert.equal(err.message, 'top: root cause');
+mod_assert.equal(err.toString(), 'VErrorChild: top: root cause');
+mod_assert.equal(err.stack.split('\n')[0], 'VErrorChild: top: root cause');
+
+suberr = new Error('root cause');
+err = new WErrorChild(suberr, 'top');
+mod_assert.ok(err instanceof Error);
+mod_assert.ok(err instanceof WError);
+mod_assert.ok(err instanceof WErrorChild);
+mod_assert.equal(err.cause(), suberr);
+mod_assert.equal(err.message, 'top');
+mod_assert.equal(err.toString(),
+	'WErrorChild: top; caused by Error: root cause');
+mod_assert.equal(err.stack.split('\n')[0],
+	'WErrorChild: top; caused by Error: root cause');
+
+
+// Test that `<Ctor>.toString()` uses the ctor name. I.e. setting
+// `<Ctor>.prototype.name` isn't necessary.
+function VErrorChildNoName() {
+	VError.apply(this, Array.prototype.slice.call(arguments));
+}
+mod_util.inherits(VErrorChildNoName, VError);
+err = new VErrorChildNoName('top');
+mod_assert.equal(err.toString(), 'VErrorChildNoName: top');
+
+function WErrorChildNoName() {
+	WError.apply(this, Array.prototype.slice.call(arguments));
+}
+mod_util.inherits(WErrorChildNoName, WError);
+err = new WErrorChildNoName('top');
+mod_assert.equal(err.toString(), 'WErrorChildNoName: top');
+
+
+// Test that `<Ctor>.prototype.name` can be used for the `.toString()`
+// when the ctor is anonymous.
+var VErrorChildAnon = function () {
+	VError.apply(this, Array.prototype.slice.call(arguments));
+};
+mod_util.inherits(VErrorChildAnon, VError);
+VErrorChildAnon.prototype.name = 'VErrorChildAnon';
+err = new VErrorChildAnon('top');
+mod_assert.equal(err.toString(), 'VErrorChildAnon: top');
+
+var WErrorChildAnon = function () {
+	WError.apply(this, Array.prototype.slice.call(arguments));
+};
+mod_util.inherits(WErrorChildAnon, WError);
+WErrorChildAnon.prototype.name = 'WErrorChildAnon';
+err = new WErrorChildAnon('top');
+mod_assert.equal(err.toString(), 'WErrorChildAnon: top');
+
+
+// Test get appropriate exception name in `.toString()` when reconstituting
+// an error instance a la:
+//    https://github.com/mcavage/node-fast/blob/master/lib/client.js#L215
+err = new VError('top');
+err.name = 'CustomNameError';
+mod_assert.equal(err.toString(), 'CustomNameError: top');
+
+err = new WError('top');
+err.name = 'CustomNameError';
+mod_assert.equal(err.toString(), 'CustomNameError: top');