From 57cc7726e956b49d92cf3496e08e898cd7938659 Mon Sep 17 00:00:00 2001 From: stdlib-bot Date: Tue, 5 Mar 2024 02:10:20 +0000 Subject: [PATCH] Auto-generated commit --- any-in-by/README.md | 185 +++++++++++++++++++++++++ any-in-by/benchmark/benchmark.js | 136 ++++++++++++++++++ any-in-by/benchmark/julia/REQUIRE | 2 + any-in-by/benchmark/julia/benchmark.jl | 144 +++++++++++++++++++ any-in-by/docs/repl.txt | 40 ++++++ any-in-by/docs/types/index.d.ts | 102 ++++++++++++++ any-in-by/docs/types/test.ts | 53 +++++++ any-in-by/examples/index.js | 37 +++++ any-in-by/lib/index.js | 50 +++++++ any-in-by/lib/main.js | 75 ++++++++++ any-in-by/package.json | 67 +++++++++ any-in-by/test/test.js | 181 ++++++++++++++++++++++++ 12 files changed, 1072 insertions(+) create mode 100644 any-in-by/README.md create mode 100644 any-in-by/benchmark/benchmark.js create mode 100644 any-in-by/benchmark/julia/REQUIRE create mode 100644 any-in-by/benchmark/julia/benchmark.jl create mode 100644 any-in-by/docs/repl.txt create mode 100644 any-in-by/docs/types/index.d.ts create mode 100644 any-in-by/docs/types/test.ts create mode 100644 any-in-by/examples/index.js create mode 100644 any-in-by/lib/index.js create mode 100644 any-in-by/lib/main.js create mode 100644 any-in-by/package.json create mode 100644 any-in-by/test/test.js diff --git a/any-in-by/README.md b/any-in-by/README.md new file mode 100644 index 00000000..a774899a --- /dev/null +++ b/any-in-by/README.md @@ -0,0 +1,185 @@ + + +# anyInBy + +> Test whether at least one property in an object passes a test implemented by a predicate function. + + + +
+ +
+ + + + + +
+ +## Usage + +```javascript +var anyInBy = require( '@stdlib/utils/any-in-by' ); +``` + +#### anyInBy( object, predicate\[, thisArg ] ) + +Tests whether at least one property in an `object` passes a test implemented by a `predicate` function. + +```javascript +function isNegative( value ) { + return ( value < 0 ); +} + +var obj = { + 'a': 1, + 'b': 2, + 'c': -1 +}; + +var bool = anyInBy( obj, isNegative ); +// returns true +``` + +If a `predicate` function returns a truthy value, the function **immediately** returns `true`. + +```javascript +function isPositive( value ) { + if ( value < 0 ) { + throw new Error( 'should never reach this line' ); + } + return ( value > 0 ); +} + +var obj = { + 'a': 1, + 'b': -2, + 'c': 3 +}; + +var bool = anyInBy( obj, isPositive ); +// returns true +``` + +The invoked `function` is provided three arguments: + +- `value`: property value +- `key`: property key +- `object`: input object + +To set the function execution context, provide a `thisArg`. + +```javascript +function sum( value ) { + this.sum += value; + this.count += 1; + return ( value < 0 ); +} + +var obj = { + 'a': 1, + 'b': 2, + 'c': 3, + 'd': -4 +}; + +var context = { + 'sum': 0, + 'count': 0 +}; + +var bool = anyInBy( obj, sum, context ); +// returns true + +var mean = context.sum / context.count; +// returns 0.5 +``` + +
+ + + + + +
+ +## Notes + +- The `obj` object may contain own properties as well as inherited properties from its prototype chain. + +- If provided an empty object, the function returns `false`. + + ```javascript + function alwaysTrue() { + return true; + } + var bool = anyInBy( {}, alwaysTrue ); + // returns false + ``` + +
+ + + + + + +
+ +## Examples + + + +```javascript +var randu = require( '@stdlib/random/base/randu' ); +var anyInBy = require( '@stdlib/utils/any-in-by' ); + +function threshold( value ) { + return ( value > 0.95 ); +} + +var bool; +var obj = {}; +var i; + +for ( i = 0; i < 100; i++ ) { + obj[i] = randu(); +} + +bool = anyInBy( obj, threshold ); +// returns +``` + +
+ + + + + +
+ +
+ + + + + +
diff --git a/any-in-by/benchmark/benchmark.js b/any-in-by/benchmark/benchmark.js new file mode 100644 index 00000000..b6a24896 --- /dev/null +++ b/any-in-by/benchmark/benchmark.js @@ -0,0 +1,136 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var bench = require( '@stdlib/bench' ); +var isBoolean = require( '@stdlib/assert/is-boolean' ).isPrimitive; +var isnan = require( '@stdlib/math/base/assert/is-nan' ); +var pkg = require( './../package.json' ).name; +var anyInBy = require( './../lib' ); + + +// MAIN // + +bench( pkg, function benchmark( b ) { + var bool; + var obj; + var i; + + function predicate( v ) { + return isnan( v ); + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + obj = { + 'a': i, + 'b': i+1, + 'c': i+2, + 'd': i+3, + 'e': i+4, + 'f': NaN + }; + bool = anyInBy( obj, predicate ); + if ( typeof bool !== 'boolean' ) { + b.fail( 'should return a boolean' ); + } + } + b.toc(); + if ( !isBoolean( bool ) ) { + b.fail( 'should return a boolean' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::built-in', function benchmark( b ) { + var bool; + var keys; + var obj; + var i; + + function predicate( v ) { + return isnan( v ); + } + function testPredicate(key) { + return predicate(obj[key]); + } + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + obj = { + 'a': i, + 'b': i+1, + 'c': i+2, + 'd': i+3, + 'e': i+4, + 'f': NaN + }; + keys = Object.keys( obj ); + bool = keys.some(testPredicate); + if ( typeof bool !== 'boolean' ) { + b.fail( 'should return a boolean' ); + } + } + b.toc(); + if ( !isBoolean( bool ) ) { + b.fail( 'should return a boolean' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); + +bench( pkg+'::loop', function benchmark( b ) { + var bool; + var keys; + var obj; + var i; + var j; + + b.tic(); + for ( i = 0; i < b.iterations; i++ ) { + obj = { + 'a': i, + 'b': i+1, + 'c': i+2, + 'd': i+3, + 'e': i+4, + 'f': NaN + }; + keys = Object.keys( obj ); + bool = false; + for ( j = 0; j < keys.length; j++ ) { + if ( isnan( obj[ keys[j] ] ) ) { + bool = true; + break; + } + } + if ( typeof bool !== 'boolean' ) { + b.fail( 'should return a boolean' ); + } + } + b.toc(); + if ( !isBoolean( bool ) ) { + b.fail( 'should be a boolean' ); + } + b.pass( 'benchmark finished' ); + b.end(); +}); diff --git a/any-in-by/benchmark/julia/REQUIRE b/any-in-by/benchmark/julia/REQUIRE new file mode 100644 index 00000000..98645e19 --- /dev/null +++ b/any-in-by/benchmark/julia/REQUIRE @@ -0,0 +1,2 @@ +julia 1.5 +BenchmarkTools 0.5.0 diff --git a/any-in-by/benchmark/julia/benchmark.jl b/any-in-by/benchmark/julia/benchmark.jl new file mode 100644 index 00000000..22297511 --- /dev/null +++ b/any-in-by/benchmark/julia/benchmark.jl @@ -0,0 +1,144 @@ +#!/usr/bin/env julia + +# @license Apache-2.0 +# +# Copyright (c) 2024 The Stdlib Authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +import BenchmarkTools +using Printf + +# Benchmark variables: +name = "any-in-by"; +repeats = 3; + +""" + print_version() + + Prints the TAP version. + + # Examples + + ``` julia + julia> print_version() + ``` +""" +function print_version() + @printf( "TAP version 13\n" ); +end + +""" + print_summary( total, passing ) + + Print the benchmark summary. + + # Arguments + + - `total`: total number of tests + - `passing`: number of passing tests + + # Examples + + ``` julia + julia> print_summary( 3, 3 ) + ``` +""" +function print_summary( total, passing ) + @printf( "#\n" ); + @printf( "1..%d\n", total ); # TAP plan + @printf( "# total %d\n", total ); + @printf( "# pass %d\n", passing ); + @printf( "#\n" ); + @printf( "# ok\n" ); +end + +""" + print_results( iterations, elapsed ) + + Print benchmark results. + + # Arguments + + - `iterations`: number of iterations + - `elapsed`: elapsed time (in seconds) + + # Examples + + ``` julia + julia> print_results( 1000000, 0.131009101868 ) + ``` +""" +function print_results( iterations, elapsed ) + rate = iterations / elapsed + + @printf( " ---\n" ); + @printf( " iterations: %d\n", iterations ); + @printf( " elapsed: %0.9f\n", elapsed ); + @printf( " rate: %0.9f\n", rate ); + @printf( " ...\n" ); +end + +""" + benchmark() + + Run a benchmark. + + # Notes + + - Benchmark results are returned as a two-element array: [ iterations, elapsed ]. + - The number of iterations is not the true number of iterations. Instead, an 'iteration' is defined as a 'sample', which is a computed estimate for a single evaluation. + - The elapsed time is in seconds. + + # Examples + + ``` julia + julia> out = benchmark(); + ``` +""" +function benchmark() + t = BenchmarkTools.@benchmark any( v -> ( isnan(v) ), [ 1, 2, 3, 4, 5, NaN ] ) samples=1e6 + + # Compute the total "elapsed" time and convert from nanoseconds to seconds: + s = sum( t.times ) / 1.0e9; + + # Determine the number of "iterations": + iter = length( t.times ); + + # Return the results: + [ iter, s ]; +end + +""" + main() + + Run benchmarks. + + # Examples + + ``` julia + julia> main(); + ``` +""" +function main() + print_version(); + for i in 1:repeats + @printf( "# julia::%s\n", name ); + results = benchmark(); + print_results( results[ 1 ], results[ 2 ] ); + @printf( "ok %d benchmark finished\n", i ); + end + print_summary( repeats, repeats ); +end + +main(); diff --git a/any-in-by/docs/repl.txt b/any-in-by/docs/repl.txt new file mode 100644 index 00000000..b4d9242b --- /dev/null +++ b/any-in-by/docs/repl.txt @@ -0,0 +1,40 @@ +{{alias}}( object, predicate[, thisArg ] ) + Tests whether at least one value in an object passes a test implemented by + a predicate function. + + The predicate function is provided three arguments: + + - `value`: the value of the current property being processed in the object + - `key`: the key of the current property being processed in the object + - `object`: the input object + + The function immediately returns upon encountering a truthy return value. + + If provided an empty object, the function returns `false`. + + Parameters + ---------- + object: Object + Input object over which to iterate. It must be non-null. + + predicate: Function + The test function. + + thisArg: any (optional) + Execution context. + + Returns + ------- + bool: boolean + The function returns `true` if the predicate function returns `true` for + any value; otherwise, it returns `false`. + + Examples + -------- + > function isNegative(value) { return value < 0 } + > var obj = { a: 1, b: -2, c: 3, d: 4 } + > var result = {{alias}}(obj, isNegative) + true + + See Also + -------- diff --git a/any-in-by/docs/types/index.d.ts b/any-in-by/docs/types/index.d.ts new file mode 100644 index 00000000..92edc7fc --- /dev/null +++ b/any-in-by/docs/types/index.d.ts @@ -0,0 +1,102 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2019 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// TypeScript Version: 4.1 + +/// + +/** +* Checks whether an object property passes a test. +* +* @returns boolean indicating whether an object property passes a test +*/ +type Nullary = ( this: U ) => boolean; + +/** +* Checks whether an object property passes a test. +* +* @param value - property value +* @returns boolean indicating whether an object property passes a test +*/ +type Unary = ( this: U, value: T ) => boolean; + +/** +* Checks whether an object property passes a test. +* +* @param value - property value +* @param key - property key +* @returns boolean indicating whether an object property passes a test +*/ +type Binary = ( this: U, value: T, index: number ) => boolean; + +/** +* Checks whether an object property passes a test. +* +* @param value - property value +* @param key - property key +* @param obj - input object +* @returns boolean indicating whether an object property passes a test +*/ +type Ternary = ( this: U, value: T, key: string, obj: { [key: string]: T } ) => boolean; + +/** +* Checks whether an object property passes a test. +* +* @param value - property value +* @param key - property key +* @param obj - input object +* @returns boolean indicating whether an object property passes a test +*/ +type Predicate = Nullary | Unary | Binary | Ternary; + +/** +* Tests whether at least one property in an object passes a test implemented by a predicate function. +* +* ## Notes +* +* - The predicate function is provided three arguments: +* +* - `value`: property value +* - `key`: property key +* - `obj`: the input object +* +* - The function immediately returns upon encountering a truthy return value. +* +* - If provided an empty object, the function returns `false`. +* +* @param obj - input object +* @param predicate - test function +* @param thisArg - execution context +* @returns boolean indicating whether at least one property passes a test +* +* @example +* function isNegative( v ) { +* return ( v < 0 ); +* } +* +* var obj = { 'a': 1, 'b': -2, 'c': 3 }; +* +* var bool = anyInBy( obj, isNegative ); +* // returns true +*/ +declare function anyInBy( obj: { [key: string]: T }, predicate: Predicate, thisArg?: ThisParameterType> ): boolean; + + +// EXPORTS // + +export = anyInBy; diff --git a/any-in-by/docs/types/test.ts b/any-in-by/docs/types/test.ts new file mode 100644 index 00000000..d02cb0e8 --- /dev/null +++ b/any-in-by/docs/types/test.ts @@ -0,0 +1,53 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2019 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +import anyInBy = require( './index' ); + +const obj = { + 'a': 1, + 'b': 2, + 'c': 3 +}; + +const isPositive = ( v: number ): boolean => { + return ( v > 0 ); +}; + +// TESTS // + +// The function returns a boolean... +{ + anyInBy( obj, isPositive ); // $ExpectType boolean +} + +// The compiler throws an error if the function is provided a second argument which is not a function... +{ + anyInBy( obj, 2 ); // $ExpectError + anyInBy( obj, false ); // $ExpectError + anyInBy( obj, true ); // $ExpectError + anyInBy( obj, 'abc' ); // $ExpectError + anyInBy( obj, {} ); // $ExpectError + anyInBy( obj, [] ); // $ExpectError +} + +// The compiler throws an error if the function is provided an invalid number of arguments... +{ + anyInBy(); // $ExpectError + anyInBy( obj ); // $ExpectError + anyInBy( obj, isPositive, {}, 3 ); // $ExpectError +} diff --git a/any-in-by/examples/index.js b/any-in-by/examples/index.js new file mode 100644 index 00000000..b32cfcda --- /dev/null +++ b/any-in-by/examples/index.js @@ -0,0 +1,37 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +var randu = require( '@stdlib/random/base/randu' ); +var anyInBy = require( './../lib' ); + +function threshold( value ) { + return ( value > 0.95 ); +} + +var bool; +var obj = {}; +var i; + +for ( i = 0; i < 100; i++ ) { + obj[i] = randu(); +} + +bool = anyInBy( obj, threshold ); +console.log( bool ); diff --git a/any-in-by/lib/index.js b/any-in-by/lib/index.js new file mode 100644 index 00000000..b2c13d82 --- /dev/null +++ b/any-in-by/lib/index.js @@ -0,0 +1,50 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +/** +* Test whether at least one property in an object passes a test implemented by a predicate function. +* +* @module @stdlib/utils/any-in-by +* +* @example +* var anyInBy = require( '@stdlib/utils/any-in-by' ); +* +* function isNegative( v ) { +* return ( v < 0 ); +* } +* +* var obj = { +* a: 1, +* b: 2, +* c: -1 +* }; +* +* var bool = anyInBy( obj, isNegative ); +* // returns true +*/ + +// MODULES // + +var main = require( './main.js' ); + + +// EXPORTS // + +module.exports = main; diff --git a/any-in-by/lib/main.js b/any-in-by/lib/main.js new file mode 100644 index 00000000..8b97576c --- /dev/null +++ b/any-in-by/lib/main.js @@ -0,0 +1,75 @@ +/** +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var isObject = require( '@stdlib/assert/is-object' ); +var isFunction = require( '@stdlib/assert/is-function' ); +var format = require( '@stdlib/string/format' ); + + +// MAIN // + +/** +* Tests whether at least one own or inherited property of an object passes a test implemented by a predicate function. +* +* @param {Object} obj - input object +* @param {Function} predicate - test function +* @param {*} [thisArg] - execution context +* @throws {TypeError} first argument must be an object +* @throws {TypeError} second argument must be a function +* @returns {boolean} boolean indicating whether at least one property passes a test +* +* @example +* function isNegative( v ) { +* return ( v < 0 ); +* } +* +* var obj = { +* 'a': 1, +* 'b': -1, +* 'c': 3 +* }; +* +* var bool = anyInBy( obj, isNegative ); +* // returns true +*/ +function anyInBy( obj, predicate, thisArg ) { + var key; + + if ( !isObject( obj ) ) { + throw new TypeError( format( 'invalid argument. First argument must be an object. Value: `%s`.', obj ) ); + } + if ( !isFunction( predicate ) ) { + throw new TypeError( format( 'invalid argument. Second argument must be a function. Value: `%s`.', predicate ) ); + } + + for ( key in obj ) { + if ( predicate.call( thisArg, obj[key], key, obj ) ) { + return true; + } + } + return false; +} + + +// EXPORTS // + +module.exports = anyInBy; diff --git a/any-in-by/package.json b/any-in-by/package.json new file mode 100644 index 00000000..d311501a --- /dev/null +++ b/any-in-by/package.json @@ -0,0 +1,67 @@ +{ + "name": "@stdlib/utils/any-in-by", + "version": "0.0.0", + "description": "Test whether at least one property in an object passes a test implemented by a predicate function.", + "license": "Apache-2.0", + "author": { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + }, + "contributors": [ + { + "name": "The Stdlib Authors", + "url": "https://github.com/stdlib-js/stdlib/graphs/contributors" + } + ], + "main": "./lib", + "directories": { + "benchmark": "./benchmark", + "doc": "./docs", + "example": "./examples", + "lib": "./lib", + "test": "./test" + }, + "types": "./docs/types", + "scripts": {}, + "homepage": "https://github.com/stdlib-js/stdlib", + "repository": { + "type": "git", + "url": "git://github.com/stdlib-js/stdlib.git" + }, + "bugs": { + "url": "https://github.com/stdlib-js/stdlib/issues" + }, + "dependencies": {}, + "devDependencies": {}, + "engines": { + "node": ">=0.10.0", + "npm": ">2.7.0" + }, + "os": [ + "aix", + "darwin", + "freebsd", + "linux", + "macos", + "openbsd", + "sunos", + "win32", + "windows" + ], + "keywords": [ + "stdlib", + "stdutils", + "stdutil", + "utilities", + "utility", + "utils", + "util", + "test", + "predicate", + "object", + "obj", + "iterate", + "validate" + ] + } + \ No newline at end of file diff --git a/any-in-by/test/test.js b/any-in-by/test/test.js new file mode 100644 index 00000000..748459b9 --- /dev/null +++ b/any-in-by/test/test.js @@ -0,0 +1,181 @@ +/* +* @license Apache-2.0 +* +* Copyright (c) 2024 The Stdlib Authors. +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +'use strict'; + +// MODULES // + +var tape = require( 'tape' ); +var noop = require( './../../noop' ); +var anyInBy = require( './../lib' ); + + +// TESTS // + +tape( 'main export is a function', function test( t ) { + t.ok( true, __filename ); + t.strictEqual( typeof anyInBy, 'function', 'main export is a function' ); + t.end(); +}); + +tape( 'the function throws an error if not provided an object', function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + function noop() {}, + /.*/, + new Date() + ]; + for (i =0; i < values.length; i++) { + t.throws( badValue( values ), TypeError, 'throws a type error when provided '+values[i] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + anyInBy( value, noop ); + }; + } +}); + +tape( 'the function throws an error if not provided a predicate function', function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + function noop() {}, + /.*/, + new Date() + ]; + for (i =0; i < values.length; i++) { + t.throws( badValue( values ), TypeError, 'throws a type error when provided '+values[i] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + anyInBy( value ); + }; + } +}); + +tape( 'the function throws an error if predicate is not a function', function test( t ) { + var values; + var i; + + values = [ + '5', + 5, + NaN, + true, + false, + null, + void 0, + [], + function noop() {}, + /.*/, + new Date() + ]; + for (i =0; i < values.length; i++) { + t.throws( badValue( values ), TypeError, 'throws a type error when provided '+values[i] ); + } + t.end(); + + function badValue( value ) { + return function badValue() { + anyInBy( value, value ); + }; + } +}); + +tape( 'the function returns `true` if at least one own property passes a test', function test( t ) { + var bool; + var obj; + + obj = { + 'a': 20, + 'b': 22, + 'c': 25 + }; + + function overAge( value ) { + return ( value > 18 ); + } + + bool = anyInBy( obj, overAge ); + + t.strictEqual( bool, true, 'returns true' ); + t.end(); +}); + +tape( 'the function returns `true` if one or more own properties pass a test', function test( t ) { + var bool; + var obj; + + obj = { + 'a': 10, + 'b': 12, + 'c': 15 + }; + + function underAge( value ) { + return ( value < 18 ); + } + + bool = anyInBy( obj, underAge ); + + t.strictEqual( bool, true, 'returns true' ); + t.end(); +}); + +tape( 'the function returns `false` if none of the own properties passes a test', function test( t ) { + var bool; + var obj; + + obj = { + 'a': 20, + 'b': 22, + 'c': 35 + }; + + function underAge( value ) { + return ( value < 18 ); + } + + bool = anyInBy( obj, underAge ); + + t.strictEqual( bool, false, 'returns false' ); + t.end(); +});