hamjest 3.7.3 → 4.0.1

package/lib/matchers/SubstringMatcher.js

@@ -1,6 +1,8 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
+const _every = require('lodash/every');
+const _filter = require('lodash/filter');
 const IsString = require('./IsString');
 const assertThat = require('../assertThat');
 const is = require('./Is').is;
@@ -9,7 +11,7 @@ const string = require('./IsString').string;
 function SubstringMatcher(substring, relation, matchesString) {
 	assertThat(substring, is(string()));
 
-	return _.create(new IsString(), {
+	return _create(new IsString(), {
 		matchesSafely(actual) {
 			return matchesString.call(this, actual);
 		},
@@ -30,42 +32,43 @@ function SubstringMatcher(substring, relation, matchesString) {
 	});
 }
 
-_.extend(SubstringMatcher, {
-	containsString(substring) {
-		return new SubstringMatcher(substring, 'containing', (actualString) => {
-			return actualString.indexOf(substring) !== -1;
-		});
-	},
-	containsStrings(...substrings) {
-		substrings.map((s) => assertThat(s, is(string())));
-		return _.create(new IsString(), {
-			matchesSafely(actual) {
-				return _.every(substrings, (s) => actual.indexOf(s) !== -1);
-			},
-			describeTo(description) {
-				description
-					.append('a string containing ')
-					.appendList('', ', ', '', substrings);
-			},
-			describeMismatchSafely(actual, description) {
-				const notFound = _.filter(substrings, (s) => actual.indexOf(s) === -1);
-				description
-					.appendList('', ', ', '', notFound)
-					.append(' could not be found in ')
-					.appendValue(actual);
-			},
-		});
-	},
-	startsWith(prefix) {
-		return new SubstringMatcher(prefix, 'starting with', (actualString) => {
-			return actualString.indexOf(prefix) === 0;
-		});
-	},
-	endsWith(suffix) {
-		return new SubstringMatcher(suffix, 'ending with', (actualString) => {
-			return actualString.indexOf(suffix, actualString.length - suffix.length) !== -1;
-		});
-	}
-});
+SubstringMatcher.containsString = function (substring) {
+	return new SubstringMatcher(substring, 'containing', (actualString) => {
+		return actualString.indexOf(substring) !== -1;
+	});
+};
+
+SubstringMatcher.containsStrings = function (...substrings) {
+	substrings.map((s) => assertThat(s, is(string())));
+	return _create(new IsString(), {
+		matchesSafely(actual) {
+			return _every(substrings, (s) => actual.indexOf(s) !== -1);
+		},
+		describeTo(description) {
+			description
+				.append('a string containing ')
+				.appendList('', ', ', '', substrings);
+		},
+		describeMismatchSafely(actual, description) {
+			const notFound = _filter(substrings, (s) => actual.indexOf(s) === -1);
+			description
+				.appendList('', ', ', '', notFound)
+				.append(' could not be found in ')
+				.appendValue(actual);
+		},
+	});
+};
+
+SubstringMatcher.startsWith = function (prefix) {
+	return new SubstringMatcher(prefix, 'starting with', (actualString) => {
+		return actualString.indexOf(prefix) === 0;
+	});
+};
+
+SubstringMatcher.endsWith = function (suffix) {
+	return new SubstringMatcher(suffix, 'ending with', (actualString) => {
+		return actualString.indexOf(suffix, actualString.length - suffix.length) !== -1;
+	});
+};
 
 module.exports = SubstringMatcher;

package/lib/matchers/failsToMatch.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const Description = require('./../Description');
 const TypeSafeMatcher = require('./TypeSafeMatcher');
 const anything = require('./IsAnything').anything;
@@ -9,7 +9,7 @@ const isMatcher = require('./Matcher').isMatcher;
 
 function failsToMatch(target, descriptionMatcher) {
 	descriptionMatcher = descriptionMatcher ? asMatcher(descriptionMatcher) : anything();
-	return _.create(new TypeSafeMatcher(), {
+	return _create(new TypeSafeMatcher(), {
 		isExpectedType: function (actual) {
 			return isMatcher(actual);
 		},

package/lib/matchers/falsy.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const Matcher = require('./Matcher');
 
 function falsy() {
-	return _.create(new Matcher(), {
+	return _create(new Matcher(), {
 		matches: function (actualValue) {
 			return !actualValue;
 		},

package/lib/matchers/hasDescription.js

@@ -1,13 +1,14 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const Description = require('./../Description');
 const TypeSafeMatcher = require('./TypeSafeMatcher');
-const acceptingMatcher = require('../utils/acceptingMatcher');
+const asMatcher = require('../utils/asMatcher');
 const isMatcher = require('./Matcher').isMatcher;
 
-module.exports = acceptingMatcher((descriptionMatcher) => {
-	return _.create(new TypeSafeMatcher(), {
+module.exports = function (valueOrMatcher) {
+	const descriptionMatcher = asMatcher(valueOrMatcher);
+	return _create(new TypeSafeMatcher(), {
 		isExpectedType: function (actual) {
 			return isMatcher(actual);
 		},
@@ -29,4 +30,4 @@ module.exports = acceptingMatcher((descriptionMatcher) => {
 			descriptionMatcher.describeMismatch(actualDescription, description);
 		}
 	});
-});
+};

package/lib/matchers/hasExactlyOneItem.js

@@ -1,18 +1,21 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
+const _filter = require('lodash/filter');
+const _map = require('lodash/map');
 const IsArray = require('./IsArray');
-const acceptingMatcher = require('../utils/acceptingMatcher');
 const promiseAgnostic = require('./promiseAgnostic');
+const asMatcher = require('../utils/asMatcher');
 
-module.exports = acceptingMatcher((matcher) => {
-	return _.create(new IsArray(), {
+module.exports = function (valueOrMatcher) {
+	const matcher = asMatcher(valueOrMatcher);
+	return _create(new IsArray(), {
 		matchesSafely: function (actual) {
-			const results = _.map(actual, (value) => {
+			const results = _map(actual, (value) => {
 				return matcher.matches(value);
 			});
 
-			return promiseAgnostic.matchesAggregate(results, (results) => _.filter(results).length === 1);
+			return promiseAgnostic.matchesAggregate(results, (results) => _filter(results).length === 1);
 		},
 		describeTo: function (description) {
 			description
@@ -24,7 +27,7 @@ module.exports = acceptingMatcher((matcher) => {
 				description.append('was empty');
 				return;
 			}
-			const results = _.map(actual, (value) => {
+			const results = _map(actual, (value) => {
 				return matcher.matches(value);
 			});
 
@@ -67,4 +70,4 @@ module.exports = acceptingMatcher((matcher) => {
 			}));
 		}
 	});
-});
+};

package/lib/matchers/hasSize.js

@@ -1,14 +1,17 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
+const _isObject = require('lodash/isObject');
+const _isString = require('lodash/isString');
+const _size = require('lodash/size');
 const TypeSafeMatcher = require('./TypeSafeMatcher');
 const FeatureMatcher = require('./FeatureMatcher');
 
 module.exports = function (valueOrMatcher) {
-	const innerMatcher = new FeatureMatcher(valueOrMatcher, 'a collection or string with size', 'size', (item) => _.size(item));
-	return _.create(new TypeSafeMatcher(), {
+	const innerMatcher = new FeatureMatcher(valueOrMatcher, 'a collection or string with size', 'size', (item) => _size(item));
+	return _create(new TypeSafeMatcher(), {
 		isExpectedType: function (actual) {
-			return _.isString(actual) || _.isObject(actual);
+			return _isString(actual) || _isObject(actual);
 		},
 		matchesSafely: innerMatcher.matches,
 		describeTo: innerMatcher.describeTo,

package/lib/matchers/inRange.js

@@ -1,21 +1,24 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
+const _inRange = require('lodash/inRange');
+const _isUndefined = require('lodash/isUndefined');
+const assertThat = require('../assertThat');
+const is = require('../matchers/Is').is;
+const isNumber = require('../matchers/IsNumber').number;
 
 module.exports = function (start, end) {
-	const __ = require('../..');
-
-	if (_.isUndefined(end)) {
+	if (_isUndefined(end)) {
 		end = start;
 		start = 0;
 	}
 
-	__.assertThat('Start', start, __.is(__.number()));
-	__.assertThat('End', end, __.is(__.number()));
+	assertThat('Start', start, is(isNumber()));
+	assertThat('End', end, is(isNumber()));
 
-	return _.create(__.number(), {
+	return _create(isNumber(), {
 		matchesSafely: function (actual) {
-			return _.inRange(actual, start, end);
+			return _inRange(actual, start, end);
 		},
 		describeTo: function (description) {
 			description

package/lib/matchers/isEmpty.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const _ = require('lodash');
+const _extend = require('lodash/extend');
 const hasSize = require('./hasSize');
 
 module.exports = function () {
-	return _.extend(hasSize(0), {
+	return _extend(hasSize(0), {
 		describeTo: function (description) {
 			description.append('an empty collection or string');
 		}

package/lib/matchers/matches.js

@@ -1,12 +1,12 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const Description = require('./../Description');
 const TypeSafeMatcher = require('./TypeSafeMatcher');
 const isMatcher = require('./Matcher').isMatcher;
 
 function matches(target) {
-	return _.create(new TypeSafeMatcher(), {
+	return _create(new TypeSafeMatcher(), {
 		isExpectedType: function (actual) {
 			return isMatcher(actual);
 		},

package/lib/matchers/promiseAgnostic.js

@@ -1,41 +1,61 @@
 'use strict';
 
-const _ = require('lodash');
-const Bluebird = require('bluebird');
+const _forEach = require('lodash/forEach');
+const _identity = require('lodash/identity');
+const _isArray = require('lodash/isArray');
+const _isFunction = require('lodash/isFunction');
+const _reduce = require('lodash/reduce');
+const _some = require('lodash/some');
 
 function resolve(promises) {
-	if (_.isArray(promises)) {
-		return Bluebird.all(promises);
+	if (_isArray(promises)) {
+		return Promise.all(promises);
 	} else {
-		return Bluebird.props(promises);
+		return Promise.resolve(promises)
+			.then((object) =>
+				Promise.all(
+					Object.entries(object).map(([key, value]) =>
+						Promise.resolve(value).then((value) => [key, value])
+					)
+				)
+			)
+			.then((items) => {
+				const results = {};
+
+				for (const [key, value] of items) {
+					results[key] = value;
+				}
+
+				return results;
+			});
 	}
 }
 
 const promiseAgnostic = {
 	matches: function (result, handler) {
 		if (isPromise(result)) {
-			return Bluebird.resolve(result).then(handler);
+			return Promise.resolve(result).then(handler);
 		} else {
 			return handler(result);
 		}
 	},
 	matchesAggregate: function (results, handler) {
-		if (_.some(results, isPromise)) {
+		if (_some(results, isPromise)) {
 			return resolve(results).then(handler);
 		} else {
 			return handler(results);
 		}
 	},
 	describeMismatchAggregate: function (results, handler, suffixFn) {
-		if (_.some(results, isPromise)) {
+		if (_some(results, isPromise)) {
 			return resolve(results).then((results) => {
-				return _.reduce(results, (chain, result, key) => {
+				return _reduce(results, (chain, result, key) => {
 					return chain.then(() => handler(result, key));
-				}, Bluebird.resolve());
+				}, Promise.resolve());
 			})
-			.then(suffixFn || _.identity);
+			.then(suffixFn || _identity);
 		} else {
-			_.forEach(results, (result, key) => {
+			_forEach(results, (result, key) => {
 				return handler(result, key);
 			});
 			if (suffixFn) {
@@ -45,9 +65,9 @@ const promiseAgnostic = {
 	},
 	describeMismatch: function (result, handler, suffixFn) {
 		if (isPromise(result)) {
-			return Bluebird.resolve(result)
+			return Promise.resolve(result)
 			.then(handler)
-			.then(suffixFn || _.identity);
+			.then(suffixFn || _identity);
 		} else {
 			handler(result);
 			if (suffixFn) {
@@ -58,7 +78,7 @@ const promiseAgnostic = {
 };
 
 function isPromise(value) {
-	return value && _.isFunction(value.then);
+	return value && _isFunction(value.then);
 }
 
 module.exports = promiseAgnostic;

package/lib/matchers/returns.js

@@ -1,6 +1,6 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const anything = require('./IsAnything').anything;
 const asMatcher = require('../utils/asMatcher');
 const func = require('./IsFunction').func;
@@ -8,7 +8,7 @@ const getType = require('../utils/getType');
 
 module.exports = function returns(resultValueOrMatcher) {
 	const resultMatcher = resultValueOrMatcher ? asMatcher(resultValueOrMatcher) : anything();
-	return _.create(func(), {
+	return _create(func(), {
 		matchesSafely: function (actual) {
 			try {
 				const result = actual();

package/lib/matchers/truthy.js

@@ -1,10 +1,10 @@
 'use strict';
 
-const _ = require('lodash');
+const _create = require('lodash/create');
 const Matcher = require('./Matcher');
 
 function truthy() {
-	return _.create(new Matcher(), {
+	return _create(new Matcher(), {
 		matches: function (actualValue) {
 			return !!actualValue;
 		},

package/lib/promiseThat.js

@@ -1,9 +1,7 @@
 'use strict';
 
-const _ = require('lodash');
+const _isFunction = require('lodash/isFunction');
 const AssertionError = require('assertion-error');
-const Bluebird = require('bluebird');
-
 const Description = require('./Description');
 
 function promiseThat(reason, actual, matcher) {
@@ -13,24 +11,24 @@ function promiseThat(reason, actual, matcher) {
 		reason = '';
 	}
 
-	return Bluebird.try(() => matcher.matches(actual)).then((result) => {
+	return Promise.resolve().then(() => matcher.matches(actual)).then((result) => {
 		if (!result) {
 			const description = new Description();
 			description.append(reason)
 				.append('\nExpected: ')
 				.appendDescriptionOf(matcher)
 				.append('\n     but: ');
-			return Bluebird.try(() => matcher.describeMismatch(actual, description))
+			return Promise.resolve().then(() => matcher.describeMismatch(actual, description))
 			.then(() => {
-				if (!_.isFunction(matcher.getExpectedForDiff) ||
-					!_.isFunction(matcher.formatActualForDiff)) {
+				if (!_isFunction(matcher.getExpectedForDiff) ||
+					!_isFunction(matcher.formatActualForDiff)) {
 					return {};
 				}
 
-				return Bluebird.all([
+				return Promise.all([
 					matcher.getExpectedForDiff(),
 					matcher.formatActualForDiff(actual)
-				]).spread((expected, actual) => {
+				]).then(([expected, actual]) => {
 					return {
 						showDiff: true,
 						expected: expected,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hamjest",
-  "version": "3.7.3",
+  "version": "4.0.1",
   "main": "index.js",
   "description": "A library of composable matchers for defining meaningful and readable assertions in JavaScript.",
   "homepage": "https://github.com/rluba/hamjest",
@@ -43,7 +43,6 @@
   ],
   "dependencies": {
     "assertion-error": "^1.1.0",
-    "bluebird": "^3.3.4",
     "lodash": "^4.17.15"
   },
   "devDependencies": {
@@ -59,15 +58,15 @@
     "eslint-config-leanbyte": "^2.0.0",
     "gulp": "^4.0.2",
     "gulp-eslint": "^6.0.0",
-    "gulp-mocha": "^7.0.2",
+    "gulp-mocha": "^8.0.0",
     "gulp-rename": "^2.0.0",
     "gulp-typescript": "^6.0.0-alpha.1",
     "gulp-uglify": "^3.0.2",
-    "karma": "^5.0.4",
+    "karma": "^6.4.1",
     "karma-chrome-launcher": "^3.0.0",
     "karma-firefox-launcher": "^1.1.0",
     "karma-mocha": "^2.0.1",
-    "mocha": "^7.1.2",
+    "mocha": "^10.2.0",
     "typescript": "^3.8.3",
     "vinyl-buffer": "^1.0.1",
     "vinyl-source-stream": "^2.0.0"

package/test/node/assertThatSpec.js

@@ -1,9 +1,7 @@
 'use strict';
 
 const assert = require('assert');
-
 const AssertionError = require('assertion-error');
-const Bluebird = require('bluebird');
 
 const __ = require('../..');
 const TestMatcher = require('./TestMatcher');
@@ -93,7 +91,7 @@ describe('assertThat', () => {
 		let thrown;
 
 		try {
-			__.assertThat('a value', new TestMatcher(() => Bluebird.resolve(true)));
+			__.assertThat('a value', new TestMatcher(() => Promise.resolve(true)));
 		} catch (e) {
 			thrown = e;
 		}

package/test/node/deferMatcher.js

@@ -1,11 +1,9 @@
 'use strict';
 
-const Bluebird = require('bluebird');
-
 function deferMatcher(matcher) {
 	return {
 		matches: function (actual) {
-			return Bluebird.try(() => matcher.matches(actual));
+			return Promise.resolve().then(() => matcher.matches(actual));
 		},
 		describeTo: function (description) {
 			description.append('deferred: ');
@@ -13,7 +11,7 @@ function deferMatcher(matcher) {
 		},
 		describeMismatch: function (actual, description) {
 			description.append('deferred: ');
-			return Bluebird.try(() => matcher.describeMismatch(actual, description));
+			return Promise.resolve().then(() => matcher.describeMismatch(actual, description));
 		}
 	};
 }

package/test/node/esm/.eslintrc

@@ -0,0 +1,5 @@
+{
+	"parserOptions": {
+		"sourceType": "module"
+	}
+}

package/test/node/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/test/node/esm/providesNamedImports.js

@@ -0,0 +1,3 @@
+import {assertThat, equalTo} from '../../../index.js';
+
+assertThat('If this test fails, ESM named-imports (might) fail.', 0, equalTo(0));

package/test/node/matchers/AllOfSpec.js

@@ -3,7 +3,7 @@
 const _ = require('lodash');
 const assert = require('assert');
 
-const __ = require('../../../lib/hamjest');
+const __ = require('../../..');
 const deferMatcher = require('../deferMatcher');
 
 describe('AllOf', () => {

package/test/node/matchers/AnyOfSpec.js

@@ -2,7 +2,7 @@
 
 const assert = require('assert');
 
-const __ = require('../../../lib/hamjest');
+const __ = require('../../..');
 
 describe('AnyOf', () => {