prime-website/docs/prime-v0.0.6/prime/index.js

Website for Prime

/*
prime
 - prototypal inheritance
*/"use strict"

var has = function(self, key){
    return Object.hasOwnProperty.call(self, key)
}

var each = function(object, method, context){
    for (var key in object) if (method.call(context, object[key], key, object) === false) break
    return object
}

/*(es5 && fixEnumBug)?*/
if (!({valueOf: 0}).propertyIsEnumerable("valueOf")){ // fix stupid IE enum 🐛

    var buggy = "constructor,toString,valueOf,hasOwnProperty,isPrototypeOf,propertyIsEnumerable,toLocaleString".split(","),
        proto = Object.prototype

    each = function(object, method, context){
        var i = buggy.length, key, value
        for (key in object) if (method.call(context, object[key], key, object) === false) return object
        while (i--){
            key = buggy[i]
            value = object[key]
            if (value !== proto[key] && method.call(context, value, key, object) === false) break
        }
        return object
    }

}/*:*/

var create = Object.create/*(es5)?*/ || function(self){
    var F = function(){}
    F.prototype = self
    return new F
}/*:*/

var mutator = function(key, value){
    this.prototype[key] = value
}

var implement = function(obj){
    each(obj, function(value, key){
        if (key !== "constructor" && key !== "inherits" && key !== "mutator") this.mutator(key, value)
    }, this)
    return this
}

var prime = function(proto){

    var superprime = proto.inherits, superproto
    if (superprime) superproto = superprime.prototype

    // if our nice proto object has no own constructor property
    // then we proceed using a ghosting constructor that all it does is
    // call the parent's constructor if it has a superprime, else an empty constructor
    // proto.constructor becomes the effective constructor
    var constructor = (has(proto, "constructor")) ? proto.constructor : (superprime) ? function(){
        return superproto.constructor.apply(this, arguments)
    } : function(){}

    if (superprime){

        // inherit from superprime
        var cproto = constructor.prototype = create(superproto)

        // setting constructor.parent to superprime.prototype
        // because it's the shortest possible absolute reference
        constructor.parent = superproto
        cproto.constructor = constructor
    }

    // inherit (kindof inherit) mutator
    constructor.mutator = proto.mutator || (superprime && superprime.mutator) || mutator
    // copy implement (this should never change)
    constructor.implement = implement

    // finally implement proto and return constructor
    return constructor.implement(proto)

}

prime.each = each
prime.has = has
prime.create = create

module.exports = prime