nldap - npm Package Compare versions

Comparing version 0.9.2 to 0.9.3

lib/change.js

@@ -0,42 +1,48 @@
+// Copyright 2011 Mark Cavage, Inc.  All rights reserved.
 
-const
-  assert    = require('assert-plus'),
-  Attribute = require('./attribute'),
-  Protocol  = require('./protocol')
+var assert = require('assert-plus');
 
-//# API
+var Attribute = require('./attribute');
+var Protocol = require('./protocol');
 
+
+///--- API
+
 function Change(options) {
-
   if (options) {
-    assert.object(options)
-    assert.optionalString(options.operation)
-  } else options = {}
-  
-  this._modification = false
-  this.operation = options.operation || options.type || 'add'
-  this.modification = options.modification || {}
+    assert.object(options);
+    assert.optionalString(options.operation);
+  } else {
+    options = {};
+  }
 
+  this._modification = false;
+  this.operation = options.operation || options.type || 'add';
+  this.modification = options.modification || {};
 }
-
 Object.defineProperties(Change.prototype, {
-
   operation: {
     get: function getOperation() {
       switch (this._operation) {
-      case 0x00: return 'add'
-      case 0x01: return 'delete'
-      case 0x02: return 'replace'
+      case 0x00: return 'add';
+      case 0x01: return 'delete';
+      case 0x02: return 'replace';
       default:
-        throw new Error('0x' + this._operation.toString(16) + ' is invalid')
+        throw new Error('0x' + this._operation.toString(16) + ' is invalid');
       }
     },
     set: function setOperation(val) {
-      assert.string(val)
+      assert.string(val);
       switch (val.toLowerCase()) {
-      case 'add':     this._operation = 0x00; break
-      case 'delete':  this._operation = 0x01; break
-      case 'replace': this._operation = 0x02; break
+      case 'add':
+        this._operation = 0x00;
+        break;
+      case 'delete':
+        this._operation = 0x01;
+        break;
+      case 'replace':
+        this._operation = 0x02;
+        break;
       default:
-        throw new Error('Invalid operation type: 0x' + val.toString(16))
+        throw new Error('Invalid operation type: 0x' + val.toString(16));
       }
@@ -46,116 +52,167 @@ },
   },
-
   modification: {
     get: function getModification() {
-      return this._modification
+      return this._modification;
     },
     set: function setModification(val) {
       if (Attribute.isAttribute(val)) {
-        this._modification = val
-        return
+        this._modification = val;
+        return;
       }
-      if (typeof (val.type) === 'string' &&
-        Object.keys(val).length == 2 &&
-        Array.isArray(val.vals)) {
+      // Does it have an attribute-like structure
+      if (Object.keys(val).length == 2 &&
+          typeof (val.type) === 'string' &&
+          Array.isArray(val.vals)) {
         this._modification = new Attribute({
           type: val.type,
           vals: val.vals
-        })
-        return
+        });
+        return;
       }
-      let keys = Object.keys(val)
-      if (keys.length > 1) throw new Error('Only one attribute per Change allowed')
-      else if (keys.length === 0) return
-      let k = keys[0]
-      let _attr = new Attribute({type: k})
-      if (Array.isArray(val[k])) val[k].forEach((v) => _attr.addValue(v.toString()))
-      else _attr.addValue(val[k].toString())
-      this._modification = _attr
+
+      var keys = Object.keys(val);
+      if (keys.length > 1) {
+        throw new Error('Only one attribute per Change allowed');
+      } else if (keys.length === 0) {
+        return;
+      }
+
+      var k = keys[0];
+      var _attr = new Attribute({type: k});
+      if (Array.isArray(val[k])) {
+        val[k].forEach(function (v) {
+          _attr.addValue(v.toString());
+        });
+      } else {
+        _attr.addValue(val[k].toString());
+      }
+      this._modification = _attr;
     },
     configurable: false
   },
-
   json: {
     get: function getJSON() {
       return {
-        operation:    this.operation,
+        operation: this.operation,
         modification: this._modification ? this._modification.json : {}
-      }
+      };
     },
     configurable: false
   }
-  
-})
+});
 
 Change.isChange = function isChange(change) {
-  if (!change || typeof (change) !== 'object') return false
-  if ((change instanceof Change) || ((typeof (change.toBer) === 'function') &&
-    (  change.modification !== undefined) &&
-    (  change.operation    !== undefined))) return true
-  return false
-}
+  if (!change || typeof (change) !== 'object') {
+    return false;
+  }
+  if ((change instanceof Change) ||
+      ((typeof (change.toBer) === 'function') &&
+      (change.modification !== undefined) &&
+      (change.operation !== undefined))) {
+    return true;
+  }
+  return false;
+};
 
-Change.compare = (a, b) => {
-  if (!Change.isChange(a) || !Change.isChange(b)) throw new TypeError('can only compare Changes')
-  if ( a.operation < b.operation) return -1
-  if ( a.operation > b.operation) return 1
-  return Attribute.compare(a.modification, b.modification)
-}
+Change.compare = function (a, b) {
+  if (!Change.isChange(a) || !Change.isChange(b))
+    throw new TypeError('can only compare Changes');
 
+  if (a.operation < b.operation)
+    return -1;
+  if (a.operation > b.operation)
+    return 1;
+
+  return Attribute.compare(a.modification, b.modification);
+};
+
+/**
+ * Apply a Change to properties of an object.
+ *
+ * @param {Object} change the change to apply.
+ * @param {Object} obj the object to apply it to.
+ * @param {Boolean} scalar convert single-item arrays to scalars. Default: false
+ */
 Change.apply = function apply(change, obj, scalar) {
-  assert.string(change.operation)
-  assert.string(change.modification.type)
-  assert.ok(Array.isArray(change.modification.vals))
-  assert.object(obj)
-  let
-    type = change.modification.type,
-    vals = change.modification.vals,
-    data = obj[type]
-  if (data !== undefined) if (!Array.isArray(data)) data = [data]
-  else data = []
+  assert.string(change.operation);
+  assert.string(change.modification.type);
+  assert.ok(Array.isArray(change.modification.vals));
+  assert.object(obj);
+
+  var type = change.modification.type;
+  var vals = change.modification.vals;
+  var data = obj[type];
+  if (data !== undefined) {
+    if (!Array.isArray(data)) {
+      data = [data];
+    }
+  } else {
+    data = [];
+  }
   switch (change.operation) {
-    case 'replace':
-      if (vals.length === 0) {
-        delete obj[type]
-        return obj
-      } else {
-        data = vals
-      }
-      break
-    case 'add':
-      let newValues = vals.filter((entry) => (data.indexOf(entry) === -1))
-      data = data.concat(newValues)
-      break
-    case 'delete':
-      data = data.filter((entry) => (vals.indexOf(entry) === -1))
-      if (data.length === 0) {
-        delete obj[type]
-        return obj
-      }
-      break
-    default: break
+  case 'replace':
+    if (vals.length === 0) {
+      // replace empty is a delete
+      delete obj[type];
+      return obj;
+    } else {
+      data = vals;
+    }
+    break;
+  case 'add':
+    // add only new unique entries
+    var newValues = vals.filter(function (entry) {
+      return (data.indexOf(entry) === -1);
+    });
+    data = data.concat(newValues);
+    break;
+  case 'delete':
+    data = data.filter(function (entry) {
+      return (vals.indexOf(entry) === -1);
+    });
+    if (data.length === 0) {
+      // Erase the attribute if empty
+      delete obj[type];
+      return obj;
+    }
+    break;
+  default:
+    break;
   }
-  if (scalar && data.length === 1) obj[type] = data[0]
-  else obj[type] = data
-  return obj
-}
+  if (scalar && data.length === 1) {
+    // store single-value outputs as scalars, if requested
+    obj[type] = data[0];
+  } else {
+    obj[type] = data;
+  }
+  return obj;
+};
 
-Change.prototype.parse = (ber) => {
-  assert.ok(ber)
-  ber.readSequence()
-  this._operation = ber.readEnumeration()
-  this._modification = new Attribute()
-  this._modification.parse(ber)
-  return true
-}
 
-Change.prototype.toBer = (ber) => {
-  assert.ok(ber)
-  ber.startSequence()
-  ber.writeEnumeration(this._operation)
-  ber = this._modification.toBer(ber)
-  ber.endSequence()
-  return ber
-}
+Change.prototype.parse = function (ber) {
+  assert.ok(ber);
 
-module.exports = Change
+  ber.readSequence();
+  this._operation = ber.readEnumeration();
+  this._modification = new Attribute();
+  this._modification.parse(ber);
+
+  return true;
+};
+
+
+Change.prototype.toBer = function (ber) {
+  assert.ok(ber);
+
+  ber.startSequence();
+  ber.writeEnumeration(this._operation);
+  ber = this._modification.toBer(ber);
+  ber.endSequence();
+
+  return ber;
+};
+
+
+///--- Exports
+
+module.exports = Change;

package.json

@@ -5,3 +5,3 @@ {
   "author":  "Andrea Leone <[e-mail]>",
-  "version": "0.9.2",
+  "version": "0.9.3",
   "license": "WTFPL",
@@ -8,0 +8,0 @@ "repository": {

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

211684

increased by0.41%

Lines of code

6181

increased by0.78%

No dependency changes