Code coverage report for master/lib/jsdoc/util/doop.js

Statements: 92.31% (36 / 39)      Branches: 77.27% (17 / 22)      Functions: 100% (4 / 4)      Lines: 92.31% (36 / 39)      Ignored: none     

All files » master/lib/jsdoc/util/ » doop.js
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 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84                1   1 504 504             1 505 505                 1 1561 1561 1561 1561 1561   1561 122     1561 505 1     504   504 193 193 238       311 311 311 1426 1426 1423     1426         505     1056       1 122       1   1  
/*global Set */
 
/**
    Deep clone a simple object. Ignores non-enumerable properties.
    @private
 */
'use strict';
 
var setDefined = typeof Set !== 'undefined';
 
function addItem(set, item) {
    Eif (setDefined) {
        set.add(item);
    }
    else if (set.indexOf(item) === -1) {
        set.push(item);
    }
}
 
function hasItem(set, item) {
    Eif (setDefined) {
        return set.has(item);
    }
    else {
        return set.indexOf(item) !== -1;
    }
}
 
// TODO: can we remove the circular-ref checking? pretty sure it's not needed anymore...
// if we need this here for some reason I'm forgetting, we should share code with jsdoc/util/dumper
function doop(o, seen) {
    var clone;
    var descriptor;
    var props;
    var i;
    var l;
 
    if (!seen) {
        seen = setDefined ? new Set() : [];
    }
 
    if (o instanceof Object && o.constructor !== Function) {
        if ( hasItem(seen, o) ) {
            clone = '<CircularRef>';
        }
        else {
            addItem(seen, o);
 
            if ( Array.isArray(o) ) {
                clone = [];
                for (i = 0, l = o.length; i < l; i++) {
                    clone[i] = (o[i] instanceof Object) ? doop(o[i], seen) : o[i];
                }
            }
            else {
                clone = Object.create( Object.getPrototypeOf(o) );
                props = Object.keys(o);
                for (i = 0, l = props.length; i < l; i++) {
                    descriptor = Object.getOwnPropertyDescriptor(o, props[i]);
                    if (descriptor.value) {
                        descriptor.value = doop(descriptor.value, seen);
                    }
 
                    Object.defineProperty(clone, props[i], descriptor);
                }
            }
        }
 
        return clone;
    }
 
    return o;
}
 
// Wrapper to avoid exposing the 'seen' parameter outside of this module.
function doopWrapper(o) {
    return doop(o);
}
 
// for backwards compatibility
doopWrapper.doop = doopWrapper;
 
module.exports = doopWrapper;