$('p').danny().text('Hello').foo().bar().fadeOut();

Your code would require

$('p').text('Hello').danny().foo().danny().bar().fadeOut();

Not a huge difference, but a conceptual one.
–Danny

(function($) {
    $.fn.danny = function (){
        var jq = this;
        return {
            foo: function(){
                return jq.each(function(){});
            },

            bar: function(){
                return jq.each(function(){});
           }
       }
    };
})(jQuery);

(function($) {
    $.fn.danny2 = function (){
        var jq = this;
        return {
            foo: function(){
                return jq.each(function(){});
            },

            bar: function(){
                return jq.each(function(){});
           }
       }
    };
})(jQuery);

$('p').danny().foo();
$('p').danny2().foo();

$('p').danny().bar();
$('p').danny2().bar();

Ariel Flesler:
http://flesler.blogspot.com/2008/04/jquerymodularize.html

John Resig:
http://dev.jquery.com/~john/plugins/space/

Flesler’s code produces results similar to yours. Resig’s code produces results similar to Saraiva’s, though chaining doesn’t seem to work.

Thanks and keep up the good work.

$(‘p’).danny.foo()
$(‘p’).danny2.foo()
$(‘p’).danny.foo().danny2.foo()

as opposed to

$(‘p’).danny().foo()
$(‘p’).danny2().foo()
$(‘p’).danny().foo().danny2().foo()

However I think the code lacks elegance and flexibility relative to yours. A merger of the two would be my ideal.

Coming from a java background, I did feel that the $.draggable(’option’, whatever) syntax was a little awkward. I just started working with jQuery and I wanted to find the “jQuery way” to namespace as I have been doing in plain old javascript up until now. Great blog. Keep up the good work.

(function($){
if ({}.__proto__){
    // mozilla  & webkit expose the prototype chain directly
    $.namespace = function(n){
        var names=n.split('.');
        var f=$.fn;
        for(var i=0;i<names.length;i++) {
            var name=names[i];
            if(!f[name]) {
                f[name] = function namespace() { // insert this function in the prototype chain
                    this.__proto__ = arguments.callee;
                    return this;
                };
                f[name].__proto__ = f;
            }
            f=f[name];
        }
    };
    $.fn.$ = function(){
        this.__proto__ = $.fn;
        return this;
    };
}else{
    // every other browser; need to copy methods
    $.namespace = function(n){
        var names=n.split('.');
        var f=$.fn;
        for(var i=0;i<names.length;i++) {
            var name=names[i];
            if(!f[name]) {
                f[name] = function namespace() { return this.extend(arguments.callee); };
            }
            f=f[name];
        }
    };
    $.fn.$ = function() { // slow but restores the default namespace
        var len = this.length;
        this.extend($.fn);
        this.length = len; // $.fn has length = 0, which messes everything up
        return this;
    };
}
})(jQuery);

It allows you to do stuff like so:

$.namespace('danny');
$.fn.danny.foo = function() {alert('color=green'); return this;};
$.namespace('danny.tools');
$.fn.danny.tools.foo = function(){alert('color=blue'); return this;};
$('p').danny().foo();
$('p').danny().tools().foo();

Creating the “danny” namespace first is just there to prove that any existing packages aren’t overriden when they are chained.