This should be it.

Author: Christopher Blum

README

@@ -0,0 +1,12 @@
+h1. Class.create([superclass][, methods...])
+
+* _superclass_ (Class) – The optional superclass to inherit methods from.
+* _methods_ (Object) – An object whose properties will be "mixed-in" to the new class. Any number of mixins can be added; later mixins take precedence.
+
+*Class.create* creates a class and returns a constructor function for instances of the class. Calling the constructor function (typically as part of a new statement) will invoke the class's initialize method.
+
+*Class.create* accepts two kinds of arguments. If the first argument is a Class, it's used as the new class's superclass, and all its methods are inherited. Otherwise, any arguments passed are treated as objects, and their methods are copied over ("mixed in") as instance methods of the new class. In cases of method name overlap, later arguments take precedence over earlier arguments.
+
+If a subclass overrides an instance method declared in a superclass, the subclass's method can still access the original method. To do so, declare the subclass's method as normal, but insert $super as the first argument. This makes $super available as a method for use within the function.
+
+*For details, see the ["inheritance tutorial on the Prototype website":http://prototypejs.org/learn/class-inheritance].*

README.textile

@@ -0,0 +1,120 @@
+/*
+Based on Alex Arnell's inheritance implementation.
+Ported by Christopher Blum (http://github.com/tiff) from Prototype (https://github.com/sstephenson/prototype) to be compatible with jQuery
+*/
+
+var Class = (function($) {
+  
+  // Some versions of JScript fail to enumerate over properties, names of which 
+  // correspond to non-enumerable properties in the prototype chain
+  var IS_DONTENUM_BUGGY = (function(){
+    for (var p in { toString: 1 }) {
+      // check actual property name, so that it works with augmented Object.prototype
+      if (p === 'toString') return false;
+    }
+    return true;
+  })();
+  
+  // Get argument names from method as array
+  function getArgumentNames(method) {
+    var names = method.toString().match(/^[\s\(]*function[^(]*\(([^)]*)\)/)[1]
+      .replace(/\/\/.*?[\r\n]|\/\*(?:.|[\r\n])*?\*\//g, '')
+      .replace(/\s+/g, '').split(',');
+    return names.length == 1 && !names[0] ? [] : names;
+  }
+  
+  // Wrap a given method
+  function wrap(method, wrapper) {
+    return function() {
+      var args = $.makeArray(arguments);
+      args.unshift($.proxy(method, this));
+      return wrapper.apply(this, args);
+    }
+  }
+  
+  // Grab all keys from an object
+  // keys({ a: 1, b: 2 }); // => ["a", "b"];
+  function keys(object) {
+    if (Object.keys) {
+      return Object.keys(object);
+    } else {
+      var results = [];
+      for (var property in object) {
+        if (object.hasOwnProperty(property)) {
+          results.push(property);
+        }
+      }
+      return results;
+    }
+  }
+  
+  function subclass() {};
+  function create() {
+    var parent = null, properties = $.makeArray(arguments);
+    if ($.isFunction(properties[0]))
+      parent = properties.shift();
+
+    function klass() {
+      this.initialize.apply(this, arguments);
+    }
+
+    $.extend(klass, Class.Methods);
+    klass.superclass = parent;
+    klass.subclasses = [];
+
+    if (parent) {
+      subclass.prototype = parent.prototype;
+      klass.prototype = new subclass;
+      parent.subclasses.push(klass);
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++)
+      klass.addMethods(properties[i]);
+
+    if (!klass.prototype.initialize)
+      klass.prototype.initialize = $.noop;
+
+    klass.prototype.constructor = klass;
+    return klass;
+  }
+
+  function addMethods(source) {
+    var ancestor   = this.superclass && this.superclass.prototype,
+        properties = keys(source);
+
+    // IE6 doesn't enumerate `toString` and `valueOf` (among other built-in `Object.prototype`) properties,
+    // Force copy if they're not Object.prototype ones.
+    // Do not copy other Object.prototype.* for performance reasons
+    if (IS_DONTENUM_BUGGY) {
+      if (source.toString != Object.prototype.toString)
+        properties.push("toString");
+      if (source.valueOf != Object.prototype.valueOf)
+        properties.push("valueOf");
+    }
+
+    for (var i = 0, length = properties.length; i < length; i++) {
+      var property = properties[i], value = source[property];
+      if (ancestor && $.isFunction(value) &&
+          getArgumentNames(value)[0] == "$super") {
+        var method = value;
+        value = wrap(function(m) {
+          return function() { return ancestor[m].apply(this, arguments); };
+        }(property), method);
+
+        value.valueOf = $.proxy(method.valueOf, method);
+        value.toString = $.proxy(method.toString, method);
+      }
+      this.prototype[property] = value;
+    }
+
+    return this;
+  }
+
+  return {
+    create: create,
+    keys: keys,
+    Methods: {
+      addMethods: addMethods
+    }
+  };
+})(jQuery);

class.js

@@ -0,0 +1,83 @@
+// base class
+var Animal = Class.create({
+  initialize: function(name) {
+    this.name = name;
+  },
+  name: "",
+  eat: function() {
+    return this.say("Yum!");
+  },
+  say: function(message) {
+    return this.name + ": " + message;
+  }
+});
+
+// subclass that augments a method
+var Cat = Class.create(Animal, {
+  eat: function($super, food) {
+    if (food instanceof Mouse) return $super();
+    else return this.say("Yuk! I only eat mice.");
+  }
+});
+
+// empty subclass
+var Mouse = Class.create(Animal, {});
+
+//mixins
+var Sellable = {
+  getValue: function(pricePerKilo) {
+    return this.weight * pricePerKilo;
+  },
+
+  inspect: function() {
+    return '#<Sellable: #{weight}kg>'.replace("#{weight}", this.weight);
+  }
+};
+
+var Reproduceable = {
+  reproduce: function(partner) {
+    if (partner.constructor != this.constructor || partner.sex == this.sex)
+      return null;
+    var weight = this.weight / 10, sex = Math.round(Math.random(1)) ? 'male' : 'female';
+    return new this.constructor('baby', weight, sex);
+  }
+};
+
+// base class with mixin
+var Plant = Class.create(Sellable, {
+  initialize: function(name, weight) {
+    this.name = name;
+    this.weight = weight;
+  },
+
+  inspect: function() {
+    return "#<Plant: #{name}>".replace("#{name}", this.name);
+  }
+});
+
+// subclass with mixin
+var Dog = Class.create(Animal, Reproduceable, {
+  initialize: function($super, name, weight, sex) {
+    this.weight = weight;
+    this.sex = sex;
+    $super(name);
+  }
+});
+
+// subclass with mixins
+var Ox = Class.create(Animal, Sellable, Reproduceable, {
+  initialize: function($super, name, weight, sex) {
+    this.weight = weight;
+    this.sex = sex;
+    $super(name);
+  },
+
+  eat: function(food) {
+    if (food instanceof Plant)
+      this.weight += food.weight;
+  },
+
+  inspect: function() {
+    return "#<Ox: #{name}>".replace("#{name}", this.name);
+  }
+});

test/fixtures.js

@@ -0,0 +1,20 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <title>jQuery - Class.create</title>
+    <link rel="stylesheet" href="http://code.jquery.com/qunit/git/qunit.css" media="screen">
+    <script src="http://ajax.googleapis.com/ajax/libs/jquery/1.5.2/jquery.min.js"></script>
+    <script src="http://code.jquery.com/qunit/git/qunit.js"></script>
+    <script src="../class.js"></script>
+    <script src="fixtures.js"></script>
+    <script src="test.js"></script>
+  </head>
+  <body>
+    <h1 id="qunit-header">jQuery - Class.create</h1>
+    <h2 id="qunit-banner"></h2>
+    <div id="qunit-testrunner-toolbar"></div>
+    <h2 id="qunit-userAgent"></h2>
+    <ol id="qunit-tests"></ol>
+    <div id="qunit-fixture"></div>
+  </body>
+</html>

test/index.html

@@ -0,0 +1,148 @@
+module("Class.create");
+
+(function($) {
+  
+  test("Creation", function() {
+    ok($.isFunction(Animal), "Animal is not a constructor");
+    same(Animal.subclasses, [Cat, Mouse, Dog, Ox]);
+    $.each(Animal.subclasses, function(i, subclass) {
+      equals(subclass.superclass, Animal);
+    });
+
+    var Bird = Class.create(Animal);
+    equals(Animal.subclasses[Animal.subclasses.length - 1], Bird);
+    // for..in loop (for some reason) doesn't iterate over the constructor property in top-level classes
+    same(Class.keys(new Animal).sort(), Class.keys(new Bird).sort());
+  });
+  
+  
+  test("Instantiation", function() {
+    var pet = new Animal("Nibbles");
+    equals(pet.name, "Nibbles", "property not initialized");
+    equals(pet.say("Hi!"), "Nibbles: Hi!");
+    equals(Animal, pet.constructor, "bad constructor reference");
+    ok(!pet.superclass);
+
+    var Empty = Class.create();
+    equals(typeof(new Empty), "object");
+  });
+  
+  
+  test("Inheritance", function() {
+    var tom = new Cat("Tom");
+    equals(tom.constructor, Cat, "bad constructor reference");
+    equals(tom.constructor.superclass, Animal, "bad superclass reference");
+    equals(tom.name, "Tom");
+    equals(tom.say('meow'), "Tom: meow");
+    equals(tom.eat(new Animal), "Tom: Yuk! I only eat mice.");
+  });
+  
+  
+  test("Superclass Method Call", function() {
+    var tom = new Cat("Tom");
+    equals(tom.eat(new Mouse), "Tom: Yum!");
+
+    // augment the constructor and test
+    var Dodo = Class.create(Animal, {
+      initialize: function($super, name) {
+        $super(name);
+        this.extinct = true;
+      },
+
+      say: function($super, message) {
+        return $super(message) + " honk honk";
+      }
+    });
+
+    var gonzo = new Dodo("Gonzo");
+    equals(gonzo.name, "Gonzo");
+    ok(gonzo.extinct, "Dodo birds should be extinct");
+    equals(gonzo.say("hello"), "Gonzo: hello honk honk");
+  });
+  
+  
+  test("Add Methods", function() {
+    var tom   = new Cat("Tom");
+    var jerry = new Mouse("Jerry");
+
+    Animal.addMethods({
+      sleep: function() {
+        return this.say("ZZZ");
+      }
+    });
+
+    Mouse.addMethods({
+      sleep: function($super) {
+        return $super() + " ... no, can't sleep! Gotta steal cheese!";
+      },
+      escape: function(cat) {
+        return this.say("(from a mousehole) Take that, " + cat.name + "!");
+      }
+    });
+
+    equals(tom.sleep(), "Tom: ZZZ", "added instance method not available to subclass");
+    equals(jerry.sleep(), "Jerry: ZZZ ... no, can't sleep! Gotta steal cheese!");
+    equals(jerry.escape(tom), "Jerry: (from a mousehole) Take that, Tom!");
+    // insure that a method has not propagated *up* the prototype chain:
+    ok(!tom.escape);
+    ok(!new Animal().escape);
+
+    Animal.addMethods({
+      sleep: function() {
+        return this.say('zZzZ');
+      }
+    });
+
+    equals(jerry.sleep(), "Jerry: zZzZ ... no, can't sleep! Gotta steal cheese!");
+  });
+  
+  
+  test("Base Class With Mixin", function() {
+    var grass = new Plant("grass", 3);
+    ok($.isFunction(grass.getValue));
+    equals(grass.inspect(), "#<Plant: grass>");
+  });
+  
+  
+  test("Subclass With Mixin", function() {
+    var snoopy = new Dog("Snoopy", 12, "male");
+    ok($.isFunction(snoopy.reproduce));
+  });
+  
+  
+  test("Subclass With Mixins", function() {
+    var cow = new Ox("cow", 400, "female");
+    equals(cow.inspect(), "#<Ox: cow>");
+    ok($.isFunction(cow.reproduce));
+    ok($.isFunction(cow.getValue));
+  });
+  
+  
+  test("Class With toString And valueOf Methods", function() {
+    var Foo = Class.create({
+      toString: function() { return "toString" },
+      valueOf: function() { return "valueOf" }
+    });
+    
+    var Bar = Class.create(Foo, {
+      valueOf: function() { return "myValueOf" }
+    });
+
+    var Parent = Class.create({
+      m1: function(){ return 'm1' },
+      m2: function(){ return 'm2' }
+    });
+    var Child = Class.create(Parent, {
+      m1: function($super) { return 'm1 child' },
+      m2: function($super) { return 'm2 child' }
+    });
+
+    ok(new Child().m1.toString().indexOf("m1 child") > -1);
+
+    equals(new Foo().toString(), "toString");
+    equals(new Foo().valueOf(), "valueOf");
+    equals(new Bar().toString(), "toString");
+    equals(new Bar().valueOf(), "myValueOf");
+  });
+  
+})(jQuery);