New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

merge-dictionaries

Package Overview
Dependencies
Maintainers
1
Versions
3
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

merge-dictionaries - npm Package Compare versions

Comparing version

0.0.1
to
0.0.3

.travis.yml
appveyor.yml
test/basic.js

14

index.js

@@ -5,11 +5,9 @@ var _ = require('@sailshq/lodash');

return _.merge(dictA, dictB, function(a, b) {
// For non-objects, arrays, and objects with no keys, just return the object reference.
// This prevents arrays from being merged together (or with strings) with horrible results,
// and prevents empty dictionary references from being broken.
if (!_.isObject(b) || _.isArray(b) || _.keys(b).length === 0) {
return b;
}
// Everything else will use the default merge strategy. Things like functions, strings,
// etc. already work nicely.
// If `a` is not a POJO, or it's an empty POJO, just replace it with `b`.
// _.isPlainObject is fine here because we don't care about clobbering dictionaries that
// came from custom constructors; our use case is merging config files together, so any
// left-hand values should either be literals, POJOS or `undefined`.
if (!_.isPlainObject(a) || _.keys(a).length === 0) { return b; }
// For non-empty dictionaries (POJO or otherwise), use the default merge strategy.
});
};

10

package.json
{
"name": "merge-dictionaries",
"version": "0.0.1",
"version": "0.0.3",
"description": "Recursively merge two dictionaries together",
"main": "index.js",
"scripts": {
"test": "echo \"Error: no test specified\" && exit 1"
"test": "mocha"
},

@@ -13,3 +13,7 @@ "author": "sgress454",

"@sailshq/lodash": "^3.10.2"
}
},
"devDependencies": {
"mocha": "3.2.0"
},
"bugs": "http://sailsjs.com/bugs"
}

76

README.md
# merge-dictionaries
A wrapper around the Lodash 3 `.merge()` function that addresses some issues with arrays and empty dictionaries.
A wrapper around the Lodash 3 `.merge()` function that addresses some issues with arrays and object references. Intended for merging configuration files together.

@@ -25,3 +25,3 @@ ### Usage

// the second, by index:
var dictA = { foo: ['owl', 'snake', 'fish' };
var dictA = { foo: ['owl', 'snake', 'fish'] };
var dictB = { foo: ['cat', 'dog']};

@@ -44,29 +44,15 @@ _.merge(dictA, dictB);

Second, dictionaries in the second argument that do not have corresponding values in the first argument are copied over by reference, _unless_ the dictionary is empty:
Second, dictionaries in the second argument that do not have corresponding dictionary values in the first argument (or whose corresponding values are `{}`) are copied over by _value_ instead of by _reference_:
```
// Non-empty dictionary object references are maintained:
var dictA = { foo: 'bar' };
var dictB = { owl: 'hoot'};
var owl = dictB.owl;
var dictB = { nested: { owl: 'hoot' } };
var owl = dictB.nested; // <-- owl is { owl: 'hoot' }
var merged = _.merge(dictA, dictB);
// Results in:
// { foo: 'bar', owl: 'hoot' }
// { foo: 'bar', nested: { owl: 'hoot' } }
console.log(owl === merged.owl);
console.log(owl === merged.nested);
// Results in:
// true
// But empty dictionary object references are NOT maintained, even nested ones:
var dictA = { foo: 'bar' };
var dictB = { nested: { empty: {} } };
var empty = dictB.nested.empty;
var merged = _.merge(dictA, dictB);
// Results in:
// { foo: 'bar', nested: { empty: {} } }
console.log(empty === merged.merged);
// Results in:
// false

@@ -91,6 +77,6 @@ ```

// Expose the public data to the outside world.
somePublicData: {}
somePublicData: publicData
// Declare a function for initializing the module.
init: function() {
somePublicData.foo = 'bar';
publicData.foo = 'bar';
}

@@ -105,10 +91,38 @@ }

The solution is very simple, because the `_.merge()` function can take a third argument that allows you to customize the merge behavior. We can use this to tell `_.merge()` to _only_ do its regular thing on objects that are _not_ arrays and that have keys. The default behavior already works fine with regular expressions, functions, Buffers and other weird objects, so handling these two cases is all we need. The actual code boils down to:
The solution is very simple, because the `_.merge()` function can take a third argument that allows you to customize the merge behavior. We can use this to tell `_.merge()` to _only_ do its regular thing when the left-hand value is a non-empty plain dictionary. In all other cases, `a` is replaced by `b`.
```
return _.merge(dictA, dictB, function(a, b) {
if (!_.isObject(b) || _.isArray(b) || _.keys(b).length === 0) {
return b;
}
});
```
> Keep in mind that this means that if `a` _looks_ like a dictionary, but was created by a custom constructor (i.e. it is not a &ldquo;plain&rdquo; dictionary, it will be replaced by `b`! For example:
>
> ```
> var myClass = function() {this.foo = 'bar'};
> var obj1 = { abc: new myClass() };
> // Result:
> // { abc: { foo: 'bar' } }
>
> var obj2 = { abc: { owl: 'hoot' } };
> var merged = mergeDictionaries(obj1, obj2);
>
> // Result:
> // { abc: { owl: 'hoot' } }
> ```
## Help
If you have questions or are having trouble, click [here](http://sailsjs.com/support).
## Bugs &nbsp; [![NPM version](https://badge.fury.io/js/merge-dictionaries.svg)](http://npmjs.com/package/merge-dictionaries)
To report a bug, [click here](http://sailsjs.com/bugs).
## Contributing
Please observe the guidelines and conventions laid out in the [Sails project contribution guide](http://sailsjs.com/documentation/contributing) when opening issues or submitting pull requests.
[![NPM](https://nodei.co/npm/merge-dictionaries.png?downloads=true)](http://npmjs.com/package/merge-dictionaries)
## License
Like the [Sails framework](http://sailsjs.com), this package is free and open-source under the [MIT License](http://sailsjs.com/license).