all files / x-object/ index.js

94.87% Statements 37/39
92.31% Branches 24/26
100% Functions 4/4
94.29% Lines 33/35
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64           30×     25×   21× 19×       17× 34×       34×       34× 20×     14×     12×       12× 27×     11×          
const services = require('./services');
((_O,metaClass)=>{
  _O.map=function(obj,fn){
      var oo={};
      _O.keys(obj).map(function(k, i) {
           oo[k] = fn.call(obj,k, obj[k]);
       });
      return oo;
   };
 
   _O.filter = function (obj, filterHandler) {
      return new services.Filter(obj).execute(filterHandler);
   };
   _O.vals=(o)=>(typeof _O.values ==='function')? _O.values(o):_O.keys(o).map((k)=>o[k]);
 
   _O.belongsTo=(small,big)=>_O.keys(small).every((k)=>(_O.equals(big[k],small[k])));
   _O.equals = function(x, y) {
          if (x === y)
              return true;
          // if both x and y are null or undefined and exactly the same
 
          if (!(x instanceof Object) || !(y instanceof Object))
              return false;
          // if they are not strictly equal, they both need to be Objects
          if (x.valueOf() === y.valueOf())
              return true
          if (x.constructor !== y.constructor)
              return false;
          // they must have the exact same prototype chain, the closest we can do is
          // test there constructor.
 
        for (var p in x) {
            Iif (!x.hasOwnProperty(p))
                continue;
            // other properties were tested using x.constructor === y.constructor
 
            Iif (!y.hasOwnProperty(p))
                return false;
            // allows to compare x[ p ] and y[ p ] when set to undefined
 
            if (x[ p ] === y[ p ])
                continue;
            // if they have the same strict value or identity then they are equal
 
            if (typeof (x[ p ]) !== "object")
                return false;
            // Numbers, Strings, Functions, Booleans must be strictly equal
 
            if (!_O.equals(x[ p ], y[ p ]))
                return false;
            // Objects and Arrays must be tested recursively
        }
 
        for (p in y) {
            if (y.hasOwnProperty(p) && !x.hasOwnProperty(p))
                return false;
            // allows x[ p ] to be set to undefined
        }
        return true;
    }
 
 
})(Object,Object.prototype)