gistfile1.js

/**
* Replaces this node with the one given,
* or replaces one child with another.
*
* replace( newNode ) -> this
*
* Replaces this node, with the one given,
* in the DOM.
*
* replace( childNode, newNode ) -> this
*
* Replaces the childNode given, with the nodeNode.
* The child must be a child of this node.
*
* replace( (newNode, newDom:Element) -> any ) -> this
*
* Adds a function to be called, when this node
* is replaced by another.
*
* foo.replace( function(newNode) {
* // on 'replace' event here
* } );
*
* replace( (newNode, newDom:Element) -> any,
* (newNode, newDom:Element) -> any ) -> this
*
* foo.replace(
* function(newNode) {
* // on 'beforeReplace' event here
* },
* function(newNode) {
* // on 'replace' event here
* }
* );
*
* The first parameter is whatever was given, for
* the replacement. This could be text, an object
* description, a BBGun node, or whatever.
*
* The second parameter is the DOM node for that
* newNode.
*
* If an Element was given, then 'newNode' and 'newDom'
* will be identical.
*
*/
replace: function( oldNode, newNode ) {
    var argsLen = arguments.length;
    assert( argsLen > 0, "not enough arguments given" );

    if ( isFunction(oldNode) ) {
        assert( argsLen === 1, "too many arguments given" );
        this.on( 'replace', oldNode );
    } else if ( argsLen === 1 ) {
        replaceNode( this, oldNode, null, 0 );
    } else if ( argsLen >= 2 ) {
        if ( isFunction(oldNode) ) {
            assert( isFunction(newNode), "'replace' event is not a function" );
            assert( argsLen === 2, "too many parameters provided" );

            this.on( 'beforeReplace', newNode );
            this.on( 'replace', newNode );
        } else if ( isFunction(newNode) ) {
            logError( "'beforeReplace' event is not a function" );
        } else {
            assert( oldNode, "falsy oldNode given" );
            assert( newNode, "falsy newNode given" );

            var oldDom, newDom;
            if ( oldNode instanceof Element ) {
                oldDom = oldNode;
            } else if ( oldNode.__isBBGun ) {
                oldDom = oldNode.dom();
            } else {
                logError( "node given, is not a HTML element", oldNode );
            }

            try {
                var newDom = bb( newNode );
            } catch ( err ) {
                logError( "replacement node is not a HTML element (perhaps you meant 'replaceWith'?)", err, err.stack );
            }

            var dom = this.dom();
            assert( oldDom.parentNode === dom , "removing node which is not a child of this element" );
            assert( newDom.parentNode === null, "adding node which is already a child of another" );

            logError( 'replacement events need to be sent to the child' );

            replaceNode( oldDom, newDom, arguments, 2 );
        }
    } else {
        logError( "too many, or not enough, parameters provided", arguments );
    }

    return this;
}