From f2bd7bde30224db3e4c943fa89a76eb39be74398 Mon Sep 17 00:00:00 2001 From: fwx913451 Date: Fri, 28 Aug 2020 18:01:43 +0800 Subject: [PATCH] fuanan add package --- extend-3.0.0.tgz | Bin 0 -> 6771 bytes nodejs-extend.spec | 50 ++++ nodejs-extend.yaml | 5 + test-index.js | 637 +++++++++++++++++++++++++++++++++++++++++++++ 4 files changed, 692 insertions(+) create mode 100644 extend-3.0.0.tgz create mode 100644 nodejs-extend.spec create mode 100644 nodejs-extend.yaml create mode 100644 test-index.js diff --git a/extend-3.0.0.tgz b/extend-3.0.0.tgz new file mode 100644 index 0000000000000000000000000000000000000000..42c0c69e31bee98d26ef18ae4c843ee5a5b13f46 GIT binary patch literal 6771 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 VU-#Gjb$_MT{{p^akktTc002o`3A6wJ literal 0 HcmV?d00001 diff --git a/nodejs-extend.spec b/nodejs-extend.spec new file mode 100644 index 0000000..f2db05b --- /dev/null +++ b/nodejs-extend.spec @@ -0,0 +1,50 @@ +%{?nodejs_find_provides_and_requires} +%global enable_tests 1 +%global barename extend +Name: nodejs-extend +Version: 3.0.0 +Release: 1 +Summary: Port of jQuery.extend for node.js and the browser +License: MIT +URL: https://www.npmjs.org/package/extend +Source0: https://registry.npmjs.org/extend/-/extend-%{version}.tgz +Source1: test-index.js +BuildArch: noarch +ExclusiveArch: %{nodejs_arches} noarch +ExclusiveArch: %{ix86} x86_64 %{arm} noarch +BuildRequires: nodejs-packaging >= 6 +%if 0%{?enable_tests} +BuildRequires: npm(tape) +%endif +%description +nodejs-extend is a port of the classic extend() method from jQuery. It behaves +as you expect. It is simple, tried and true. + +%prep +%setup -q -n package +install -D -p -m0644 %{SOURCE1} test/index.js +rm -rf node_modules/ +%nodejs_fixdep --caret + +%build + +%install +mkdir -p %{buildroot}%{nodejs_sitelib}/extend +cp -pr package.json index.js \ + %{buildroot}%{nodejs_sitelib}/extend +%nodejs_symlink_deps + +%check +%if 0%{?enable_tests} +%nodejs_symlink_deps --check +node test/index.js +%endif + +%files +%doc README.md +%license LICENSE +%{nodejs_sitelib}/extend/ + +%changelog +* Thu Aug 20 2020 Anan Fu - 3.0.0-1 +- package init diff --git a/nodejs-extend.yaml b/nodejs-extend.yaml new file mode 100644 index 0000000..762fbe5 --- /dev/null +++ b/nodejs-extend.yaml @@ -0,0 +1,5 @@ +git_url: https://www.npmjs.org/package/extend +version_control: registry +src_repo: https://registry.npmjs.org/extend/- +tag_prefix: "^" +seperator: "." diff --git a/test-index.js b/test-index.js new file mode 100644 index 0000000..cb4117f --- /dev/null +++ b/test-index.js @@ -0,0 +1,637 @@ +'use strict'; + +var extend = require('../index'); +var test = require('tape'); + +var str = 'me a test'; +var integer = 10; +var arr = [1, 'what', new Date(81, 8, 4)]; +var date = new Date(81, 4, 13); + +var Foo = function () {}; + +var obj = { + str: str, + integer: integer, + arr: arr, + date: date, + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() +}; + +var deep = { + ori: obj, + layer: { + integer: 10, + str: 'str', + date: new Date(84, 5, 12), + arr: [101, 'dude', new Date(82, 10, 4)], + deep: { + str: obj.str, + integer: integer, + arr: obj.arr, + date: new Date(81, 7, 4) + } + } +}; + +test('missing arguments', function (t) { + t.deepEqual(extend(undefined, { a: 1 }), { a: 1 }, 'missing first argument is second argument'); + t.deepEqual(extend({ a: 1 }), { a: 1 }, 'missing second argument is first argument'); + t.deepEqual(extend(true, undefined, { a: 1 }), { a: 1 }, 'deep: missing first argument is second argument'); + t.deepEqual(extend(true, { a: 1 }), { a: 1 }, 'deep: missing second argument is first argument'); + t.deepEqual(extend(), {}, 'no arguments is object'); + t.end(); +}); + +test('merge string with string', function (t) { + var ori = 'what u gonna say'; + var target = extend(ori, str); + var expectedTarget = { + 0: 'm', + 1: 'e', + 2: ' ', + 3: 'a', + 4: ' ', + 5: 't', + 6: 'e', + 7: 's', + 8: 't' + }; + + t.equal(ori, 'what u gonna say', 'original string 1 is unchanged'); + t.equal(str, 'me a test', 'original string 2 is unchanged'); + t.deepEqual(target, expectedTarget, 'string + string is merged object form of string'); + t.end(); +}); + +test('merge string with number', function (t) { + var ori = 'what u gonna say'; + var target = extend(ori, 10); + + t.equal(ori, 'what u gonna say', 'original string is unchanged'); + t.deepEqual(target, {}, 'string + number is empty object'); + + t.end(); +}); + +test('merge string with array', function (t) { + var ori = 'what u gonna say'; + var target = extend(ori, arr); + + t.equal(ori, 'what u gonna say', 'original string is unchanged'); + t.deepEqual(arr, [1, 'what', new Date(81, 8, 4)], 'array is unchanged'); + t.deepEqual(target, { + 0: 1, + 1: 'what', + 2: new Date(81, 8, 4) + }, 'string + array is array'); + t.end(); +}); + +test('merge string with date', function (t) { + var ori = 'what u gonna say'; + var target = extend(ori, date); + + var testDate = new Date(81, 4, 13); + t.equal(ori, 'what u gonna say', 'original string is unchanged'); + t.deepEqual(date, testDate, 'date is unchanged'); + t.deepEqual(target, testDate, 'string + date is date'); + t.end(); +}); + +test('merge string with obj', function (t) { + var ori = 'what u gonna say'; + var target = extend(ori, obj); + + t.equal(ori, 'what u gonna say', 'original string is unchanged'); + var testObj = { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + t.deepEqual(obj, testObj, 'original obj is unchanged'); + t.deepEqual(target, testObj, 'string + obj is obj'); + t.end(); +}); + +test('merge number with string', function (t) { + var ori = 20; + var target = extend(ori, str); + + t.equal(ori, 20, 'number is unchanged'); + t.equal(str, 'me a test', 'string is unchanged'); + t.deepEqual(target, { + 0: 'm', + 1: 'e', + 2: ' ', + 3: 'a', + 4: ' ', + 5: 't', + 6: 'e', + 7: 's', + 8: 't' + }, 'number + string is object form of string'); + t.end(); +}); + +test('merge number with number', function (t) { + t.deepEqual(extend(20, 10), {}, 'number + number is empty object'); + t.end(); +}); + +test('merge number with array', function (t) { + var target = extend(20, arr); + + t.deepEqual(arr, [1, 'what', new Date(81, 8, 4)], 'array is unchanged'); + t.deepEqual(target, { + 0: 1, + 1: 'what', + 2: new Date(81, 8, 4) + }, 'number + arr is object with array contents'); + t.end(); +}); + +test('merge number with date', function (t) { + var target = extend(20, date); + var testDate = new Date(81, 4, 13); + + t.deepEqual(date, testDate, 'original date is unchanged'); + t.deepEqual(target, testDate, 'number + date is date'); + t.end(); +}); + +test('merge number with object', function (t) { + var target = extend(20, obj); + var testObj = { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + + t.deepEqual(obj, testObj, 'obj is unchanged'); + t.deepEqual(target, testObj, 'number + obj is obj'); + t.end(); +}); + +test('merge array with string', function (t) { + var ori = [1, 2, 3, 4, 5, 6]; + var target = extend(ori, str); + + t.deepEqual(ori, str.split(''), 'array is changed to be an array of string chars'); + t.equal(str, 'me a test', 'string is unchanged'); + t.deepEqual(target, { + 0: 'm', + 1: 'e', + 2: ' ', + 3: 'a', + 4: ' ', + 5: 't', + 6: 'e', + 7: 's', + 8: 't' + }, 'array + string is object form of string'); + t.end(); +}); + +test('merge array with number', function (t) { + var ori = [1, 2, 3, 4, 5, 6]; + var target = extend(ori, 10); + + t.deepEqual(ori, [1, 2, 3, 4, 5, 6], 'array is unchanged'); + t.deepEqual(target, ori, 'array + number is array'); + t.end(); +}); + +test('merge array with array', function (t) { + var ori = [1, 2, 3, 4, 5, 6]; + var target = extend(ori, arr); + var testDate = new Date(81, 8, 4); + var expectedTarget = [1, 'what', testDate, 4, 5, 6]; + + t.deepEqual(ori, expectedTarget, 'array + array merges arrays; changes first array'); + t.deepEqual(arr, [1, 'what', testDate], 'second array is unchanged'); + t.deepEqual(target, expectedTarget, 'array + array is merged array'); + t.end(); +}); + +test('merge array with date', function (t) { + var ori = [1, 2, 3, 4, 5, 6]; + var target = extend(ori, date); + var testDate = new Date(81, 4, 13); + var testArray = [1, 2, 3, 4, 5, 6]; + + t.deepEqual(ori, testArray, 'array is unchanged'); + t.deepEqual(date, testDate, 'date is unchanged'); + t.deepEqual(target, testArray, 'array + date is array'); + t.end(); +}); + +test('merge array with object', function (t) { + var ori = [1, 2, 3, 4, 5, 6]; + var target = extend(ori, obj); + var testObject = { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + + t.deepEqual(obj, testObject, 'obj is unchanged'); + t.equal(ori.length, 6, 'array has proper length'); + t.equal(ori.str, obj.str, 'array has obj.str property'); + t.equal(ori.integer, obj.integer, 'array has obj.integer property'); + t.deepEqual(ori.arr, obj.arr, 'array has obj.arr property'); + t.equal(ori.date, obj.date, 'array has obj.date property'); + + t.equal(target.length, 6, 'target has proper length'); + t.equal(target.str, obj.str, 'target has obj.str property'); + t.equal(target.integer, obj.integer, 'target has obj.integer property'); + t.deepEqual(target.arr, obj.arr, 'target has obj.arr property'); + t.equal(target.date, obj.date, 'target has obj.date property'); + t.end(); +}); + +test('merge date with string', function (t) { + var ori = new Date(81, 9, 20); + var target = extend(ori, str); + var testObject = { + 0: 'm', + 1: 'e', + 2: ' ', + 3: 'a', + 4: ' ', + 5: 't', + 6: 'e', + 7: 's', + 8: 't' + }; + + t.deepEqual(ori, testObject, 'date is changed to object form of string'); + t.equal(str, 'me a test', 'string is unchanged'); + t.deepEqual(target, testObject, 'date + string is object form of string'); + t.end(); +}); + +test('merge date with number', function (t) { + var ori = new Date(81, 9, 20); + var target = extend(ori, 10); + + t.deepEqual(ori, {}, 'date is changed to empty object'); + t.deepEqual(target, {}, 'date + number is empty object'); + t.end(); +}); + +test('merge date with array', function (t) { + var ori = new Date(81, 9, 20); + var target = extend(ori, arr); + var testDate = new Date(81, 9, 20); + var testArray = [1, 'what', new Date(81, 8, 4)]; + + t.deepEqual(ori, testDate, 'date is unchanged'); + t.deepEqual(arr, testArray, 'array is unchanged'); + t.deepEqual(target, testDate, 'date + array is date'); + t.end(); +}); + +test('merge date with date', function (t) { + var ori = new Date(81, 9, 20); + var target = extend(ori, date); + + t.deepEqual(ori, {}, 'date is empty object'); + t.deepEqual(target, {}, 'date + date is empty object'); + t.end(); +}); + +test('merge date with object', function (t) { + var ori = new Date(81, 9, 20); + var target = extend(ori, obj); + var testDate = new Date(81, 8, 4); + var testObject = { + str: 'me a test', + integer: 10, + arr: [1, 'what', testDate], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + + t.deepEqual(obj, testObject, 'original object is unchanged'); + t.deepEqual(ori, testObject, 'date becomes original object'); + t.deepEqual(target, testObject, 'date + object is object'); + t.end(); +}); + +test('merge object with string', function (t) { + var testDate = new Date(81, 7, 26); + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: testDate + }; + var target = extend(ori, str); + var testObj = { + 0: 'm', + 1: 'e', + 2: ' ', + 3: 'a', + 4: ' ', + 5: 't', + 6: 'e', + 7: 's', + 8: 't', + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: testDate + }; + + t.deepEqual(ori, testObj, 'original object updated'); + t.equal(str, 'me a test', 'string is unchanged'); + t.deepEqual(target, testObj, 'object + string is object + object form of string'); + t.end(); +}); + +test('merge object with number', function (t) { + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + var testObject = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + var target = extend(ori, 10); + t.deepEqual(ori, testObject, 'object is unchanged'); + t.deepEqual(target, testObject, 'object + number is object'); + t.end(); +}); + +test('merge object with array', function (t) { + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + var target = extend(ori, arr); + var testObject = { + 0: 1, + 1: 'what', + 2: new Date(81, 8, 4), + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + + t.deepEqual(ori, testObject, 'original object is merged'); + t.deepEqual(arr, [1, 'what', testObject[2]], 'array is unchanged'); + t.deepEqual(target, testObject, 'object + array is merged object'); + t.end(); +}); + +test('merge object with date', function (t) { + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + var target = extend(ori, date); + var testObject = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26) + }; + + t.deepEqual(ori, testObject, 'original object is unchanged'); + t.deepEqual(date, new Date(81, 4, 13), 'date is unchanged'); + t.deepEqual(target, testObject, 'object + date is object'); + t.end(); +}); + +test('merge object with object', function (t) { + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26), + foo: 'bar' + }; + var target = extend(ori, obj); + var expectedObj = { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + var expectedTarget = { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }; + + t.deepEqual(obj, expectedObj, 'obj is unchanged'); + t.deepEqual(ori, expectedTarget, 'original has been merged'); + t.deepEqual(target, expectedTarget, 'object + object is merged object'); + t.end(); +}); + +test('deep clone', function (t) { + var ori = { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26), + layer: { + deep: { + integer: 42 + } + } + }; + var target = extend(true, ori, deep); + + t.deepEqual(ori, { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26), + ori: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }, + layer: { + integer: 10, + str: 'str', + date: new Date(84, 5, 12), + arr: [101, 'dude', new Date(82, 10, 4)], + deep: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 7, 4) + } + } + }, 'original object is merged'); + t.deepEqual(deep, { + ori: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }, + layer: { + integer: 10, + str: 'str', + date: new Date(84, 5, 12), + arr: [101, 'dude', new Date(82, 10, 4)], + deep: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 7, 4) + } + } + }, 'deep is unchanged'); + t.deepEqual(target, { + str: 'no shit', + integer: 76, + arr: [1, 2, 3, 4], + date: new Date(81, 7, 26), + ori: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }, + layer: { + integer: 10, + str: 'str', + date: new Date(84, 5, 12), + arr: [101, 'dude', new Date(82, 10, 4)], + deep: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 7, 4) + } + } + }, 'deep + object + object is deeply merged object'); + + target.layer.deep = 339; + t.deepEqual(deep, { + ori: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 4, 13), + constructor: 'fake', + isPrototypeOf: 'not a function', + foo: new Foo() + }, + layer: { + integer: 10, + str: 'str', + date: new Date(84, 5, 12), + arr: [101, 'dude', new Date(82, 10, 4)], + deep: { + str: 'me a test', + integer: 10, + arr: [1, 'what', new Date(81, 8, 4)], + date: new Date(81, 7, 4) + } + } + }, 'deep is unchanged after setting target property'); + // ----- NEVER USE EXTEND WITH THE ABOVE SITUATION ------------------------------ + t.end(); +}); + +test('deep clone; arrays are merged', function (t) { + var defaults = { + arr: [1, 2, 3] + }; + var override = { + arr: ['x'] + }; + var expectedTarget = { + arr: ['x', 2, 3] + }; + + var target = extend(true, defaults, override); + + t.deepEqual(target, expectedTarget, 'arrays are merged'); + t.end(); +}); + +test('deep clone === false; objects merged normally', function (t) { + var defaults = { + a: 1 + }; + var override = { + a: 2 + }; + var target = extend(false, defaults, override); + t.deepEqual(target, override, 'deep === false handled normally'); + t.end(); +}); + +test('pass in null; should create a valid object', function (t) { + var override = { + a: 1 + }; + var target = extend(null, override); + t.deepEqual(target, override, 'null object handled normally'); + t.end(); +}); + +test('works without Array.isArray', function (t) { + var savedIsArray = Array.isArray; + Array.isArray = false; // don't delete, to preserve enumerability + var target = []; + var source = [1, [2], { 3: true }]; + t.deepEqual( + extend(true, target, source), + [1, [2], { 3: true }], + 'It works without Array.isArray' + ); + Array.isArray = savedIsArray; + t.end(); +});