i got fresh fruits

var Person = Class.create({
  
  // class declaration
  self: {
    // class method
    find: function(name) {
      return this.population.find(function(p) {
        return p.name == name;
      });
    },

    // class attribute
    population: []
  }

  // instance declaration

  // mixins
  include: [ Comparable, Loggable ],  // imaginary mixins

  initialize: function(name) {
    this.name = name;
    // accessing class from instance
    this.constructor.population.push(this);
  },

  introduce: function() {
    return My name is  + this.name;
  }

});

// We extend Person class
var Employee = Class.create(Person, {
  initialize: function(name, salary) {
    // call the parent initialize method
    this.callSuper('initialize', name);
    this.salary = salary;
  },
 
  introduce: function() {
    return this.callSuper('introduce') +  and I earn  + this.salary;
  }
});

var jack = new Person('Jack');
var billy = new Employee('Billy', 2000);

jack.introduce();
// -> My name is Jack

billy.introduce();
// -> My name is Billy and I earn 2000

Person.find('Jack').name;
// -> 'Jack'

Person.find('Billy');
// -> null

Employee.find('Billy').name;
// -> 'Billy'

/*
Copyright (c) 2007 Samuel Lebeau

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the Software), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

THE SOFTWARE IS PROVIDED AS IS, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
*/

var Class = {
  create: function(superclass, body) {
    if (!body) {
      var body = superclass || {};
      var superclass = null;
    }
    var klass = function() {
      this.constructor = klass;
      if (!Class._prototyping_) this.initialize.apply(this, arguments);
    }
    if (superclass) {
      Object.extend(klass, superclass);
      Object.extend(klass, {
        superclass: superclass,
        callSuper: Class._bindCallSuper(superclass),
        prototype: Class._inheritPrototype(superclass.prototype)
      });
      klass.prototype.callSuper = Class._bindCallSuper(superclass.prototype)
    }
    klass.include = Class._include;
    klass.extend = Class._extend; 
    if (body.self) {
      Object.extend(klass, body.self);
      delete body.self;
    }
    if (body.include) {
      [ body.include ].flatten().each(function(mixin) {
        klass.include(mixin);
      });
      delete body.include;
    }
    Object.extend(klass.prototype, body);
    if (!klass.prototype.initialize)
      klass.prototype.initialize = Prototype.emptyFunction;
    if (klass.initialize) klass.initialize();
    return klass;
  },
  _inheritPrototype: function(proto) {
    var inheritance = function() {};
    inheritance.prototype = proto;
    Class._prototyping_ = true;
    var prototype = new inheritance();
    delete Class._prototyping_;
    return prototype;
  },
  _include: function(mixin) { Object.extend(this.prototype, mixin); },
  _extend: function(mixin) { Object.extend(this, mixin); },
  _bindCallSuper: function(ancestor) {
    return function() {
      var args = $A(arguments), method = args.shift(), ret;
      this.callSuper = ancestor.callSuper;
      try { 
        if (ancestor[method] && ancestor[method] != this[method])
          ret = ancestor[method].apply(this, args);
        else if (!this.callSuper)
          throw new Class._noSuperMethodError(method);
        else
          ret = this.callSuper.apply(this, arguments);
      }
      finally { this.callSuper = arguments.callee }
      if (ret) return ret;
    }
  },
  _noSuperMethodError: function(method) {
    this.name = 'NoSuperMethodError';
    this.message = 'no super method ' + method + ''; 
  }
}