# Stringifying

    'use strict'

    {isArray} = Array

    module.exports = (utils) ->

## simplify(*Object* object, [*Object* options])

Convert the given object into the most simplified format with no cyclic references and more.

Such object can be easily stringified later using standard *JSON.stringify()*.

Use utils.assemble() function to restore the object into the initial structure.

Second parameter is an config object (all 'false' by default):
  - *properties* - save properties descriptors (getters, config etc.),
  - *protos* - save protos as objects,
  - *constructors* - include constructor functions.

```javascript
var obj = {};
obj.self = obj;
console.log(JSON.stringify(utils.simplify(obj)));
```

If *protos* is *false* and *constructors* is *true*,
object will be recognized as an instance.

```javascript
function Sample(){
  this.fromInstance = 1;
}
Sample.prototype.fromPrototype = 1;

var sample = new Sample;
var parts = utils.simplify(sample, {constructors: true});
var clone = utils.assemble(json);

console.log(clone instanceof Sample)
// it's true because 'protos' option is false and 'constructors' is true
// won't work for json, because functions are not stringified ...
```

        utils.simplify = do ->
            nativeProtos = [Array::, Object::]
            nativeCtors = [Array, Object]

            (obj, opts = {}) ->
                null
                `//<development>`
                unless utils.isObject(obj)
                    throw new Error 'utils.simplify object must be an object'
                unless utils.isPlainObject(opts)
                    throw new Error 'utils.simplify options must be a plain object'
                `//</development>`

                optsProps = opts.properties ?= false
                optsProtos = opts.protos ?= false
                optsCtors = opts.constructors ?= false
                optsInsts = opts.instances = not optsProtos and optsCtors

                # list of objects
                objs = []

                # list of lists of ids per object
                ids = []

                # lists of keys to references per object
                references = {}

                # objects constructors
                if optsCtors then ctors = {}

                # proto destination to proto object
                if optsProtos then protos = {}

                # get cyclic references in the object
                cyclic = (obj) ->

                    len = objs.push obj
                    ids.push objIds = []

                    for key, value of obj when obj.hasOwnProperty key

                        unless value and typeof value is 'object'
                            continue

                        # don't check getters values
                        if optsProps and exports.lookupGetter obj, key
                            objIds.push null
                            continue

                        # check whether obj already exists
                        unless ~(i = objs.indexOf value)
                            i = cyclic value

                        objIds.push i

                    # cycle proto
                    if optsProtos and proto = getPrototypeOf obj

                        # don't save protos for native ones (Array, Object, etc..)
                        if ~(nativeProtos.indexOf proto)
                            i = null

                        # find recursively if it's for first time
                        else unless ~(i = objs.indexOf proto)
                            i = cyclic proto

                        objIds.push i

                    len - 1

                # parse object
                parse = (obj, index) ->

                    r = if isArray obj then [] else {}
                    objIds = ids[index]

                    # Create `references` for each object with keys which are a references to others
                    # Value of each property will be changed to referenced object id
                    obji = 0
                    objReferences = null
                    for key, value of obj when obj.hasOwnProperty key

                        r[key] = value

                        isReference = false

                        # save as reference
                        if value and typeof value is 'object'
                            objReferences ?= []

                            objId = value = objIds[obji++]

                            # with `optsProps` id can be a null when value is an object
                            if value isnt null
                                isReference = true
                                objReferences.push key

                        # save as property description
                        if optsProps
                            desc = getObjOwnPropDesc obj, key
                            desc.value = value if isReference
                            value = desc

                        # override prop value as referenced object id
                        r[key] = value

                    # save reference to proto
                    if optsProtos and getPrototypeOf obj
                        protoObjId = objIds[obji++]
                        if protoObjId isnt null
                            protos[index] = protoObjId

                    # save ctor if needed
                    if optsCtors and ctor = obj.constructor

                        # save for instance or for prototype depend on the flag
                        if optsInsts or obj.hasOwnProperty('constructor')

                            # omits native constructors (Array, Object etc.)
                            unless ~(nativeCtors.indexOf ctor)
                                ctors[index] = ctor

                    # save object references
                    if objReferences then references[index] = objReferences

                    r

                # find cycles
                cyclic obj

                # parse all found objects
                for value, i in objs
                    objs[i] = parse value, i

                # return
                opts: opts
                objects: objs
                references: references
                protos: protos
                constructors: ctors

## assemble(*PlainObject* object)

Backward utils.simplify() operation.

        utils.assemble = do ->
            ctorPropConfig = value: null

            (obj) ->
                null
                `//<development>`
                unless utils.isPlainObject(obj)
                    throw new Error 'utils.assemble object must be a plain object'
                `//</development>`

                {opts, objects, references, protos, constructors} = obj

                optsProps = opts.properties
                optsProtos = opts.protos
                optsCtors = opts.constructors
                optsInsts = opts.instances

                # list of all referenced objects ids
                refsIds = []

                # set references
                if optsProps
                    for objI, refs of references
                        obj = objects[objI]

                        for ref in refs
                            refsIds.push obj[ref].value
                            obj[ref].value = objects[obj[ref].value]
                else
                    for objI, refs of references
                        obj = objects[objI]

                        for ref in refs
                            refsIds.push obj[ref]
                            obj[ref] = objects[obj[ref]]

                # set properties
                if optsProps
                    for obj in objects
                        for key, value of obj when obj.hasOwnProperty key
                            defObjProp obj, key, value

                # set protos
                for objI, refI of protos
                    objects[objI] = utils.setPrototypeOf objects[objI], objects[refI]

                # set objects as instances
                if optsInsts
                    for objI, func of constructors
                        object = objects[objI] = utils.setPrototypeOf objects[objI], func::

                        # call `fromAssebled` if exists
                        func.fromAssembled? object

                # .. or set ctors as properties
                else if optsCtors
                    for objI, func of constructors
                        ctorPropConfig.value = func
                        defObjProp objects[objI], 'constructor', ctorPropConfig

                # update references, because same of them could changed by `setPrototypeOf`
                refId = 0
                for objI, refs of references
                    obj = objects[objI]

                    for ref in refs
                        obj[ref] = objects[refsIds[refId++]]

                objects[0]