i got fresh fruits

PeriodicalExecuter.addMethods(Advisable);

PeriodicalExecuter.prototype.addAroundAdvice('execute', function(proceed) {
  // assuming the existence of some benchmark function
  var duration = benchmark(proceed);
  console.log('Periodical execution took '+duration+'s');
});
// For now every single instance of PeriodicalExecuter will log the execution duration.

var greeter = Object.extend({
  congrat: function() {
    return "Congratulations";
  }
}, Advisable);

greeter.addAfterAdvice('congrat', function(returnValue) {
  return returnValue + " for Prototype 1.6, you guys made a great work."
});

greeter.congrat();
// "Congratulations for Prototype 1.6, you guys made a great work."

var Example = Class.create(Advisable, {
  example: function() {
    console.log('in original method');
  }
});

var ex = new Example();
ex.addAroundAdvice('example', function(proceed) {
  console.log('around, before (instance advice)');
  proceed();
  console.log('around, after (instance advice)');
});

Example.prototype.addBeforeAdvice('example', function() {
  console.log('before (prototype advice)');
});

ex.example();

// Guess what's in console ?

// around, before (instance advice)
// before (prototype advice)
// in original method
// around, after (instance advice)

Object.keys(Advisable).each(function(methodName) {
  Example[methodName] = Advisable[methodName].bind(Example.prototype);
});

// now
Example.addBeforeAdvice('example', advice);
// is equivalent to
Example.prototype.addBeforeAdvice('example', advice);
// but maybe sexier :p

  paste = Pastis.paste a_string, :language => :text, :private => true
  puts paste.url, paste.body
  
  results = Pastis.search('mixin')
  puts results.first.body
  
  puts results.next_page.first.preview unless results.last_page?

#!/usr/bin/env ruby
require 'rubygems'
require 'pastis'

input = ENV['TM_SELECTED_TEXT'] || File.read(ENV['TM_FILEPATH'])

languages = {
  /source\.ruby/ => :ruby,
  /text\.html\.basic/ => :html,
  /text\.html\.ruby/ => :rhtml,
  /source\.js/ => :javascript,
  /source\.(c|c\+\+)/ => :c,
  /source\.sql/ => :sql,
  /source\.diff/ => :diff
}

language = languages[languages.keys.find { |pattern| ENV['TM_SCOPE'] =~ pattern }] || :plaintext

paste = Pastis.paste(input, :language => language)

`open #{paste.url}`

var Widget = Class.create({
  defaultOptions: {
    className: 'widget',
    theme: 'BeOS'
  },
  
  initialize: function(element, options) {
    this.setOptions(options);
    ...
  }
});

// For 1.6
Class.mixin(Widget, Options);

// For 1.5
Object.extend(Widget.prototype, Options);

  add = slambda '|x, y| x + y'

  add.call(10, Math::PI)
  # => 13.1415926535898

  add.source
  # => '|x, y| x + y'
  
  add.to_s      
  # => 'slambda("|x, y| x + y")'

  Marshal.load(Marshal.dump(add)).call(2, 3)
  # => 5

  var Class = Object.extend(function(superclass, body) {
    if (typeof superclass != 'function')
      body = superclass, superclass = Base;

    var cls = function() {
      if (arguments[0] !== Class._extending_ && this.initialize)
        this.initialize.apply(this, arguments);
    }
    // Getting properties from Class.prototype
    Object.extend(cls, this);
    Object.extend(cls, {
      superclass: superclass,
      prototype: new superclass(Class._extending_),
      subclasses: []
    });

    cls.constructor = Class;
    cls.prototype.constructor = cls;

    if (body) cls.classEval(body);

    superclass.subclasses.push(cls);
    if (superclass.inherited) superclass.inherited(cls);
    if (cls.afterCreation) cls.afterCreation();

    return cls;
  },
  {
    _extending_: new Object(),

    // backward compatibility
    create: function(superclass, body) {
      return new this(superclass, body);
    }
  });

  Class.prototype = {  
    extend: function(object) {
      Object.extend(this, object);
    },  

    include: function() {
      this.prototype.extend(mixin);
      if (Object.isFunction(mixin.included))
        mixin.included(this);
    },

    classEval: function(body) {
      this.extend(Object.erase(body, 'self') || {});
      if (typeof body.include == 'object')
        [ Object.erase(body, 'include') ].flatten().each(this.include.bind(this));
      this.prototype.extend(body);
    }
  };

  var Base = Object.extend(function() {}, {
    subclasses: [],
    constructor: Class
  });

  Base.prototype = {
    extend: function(object) {
      var ancestor = this.constructor.superclass.prototype;

      for (var property in object) {
        if (Object.isFunction(object[property]) && 
            Object.isFunction(ancestor[property]) &&
            object[property].toString().include('$super')) {

          var method = object[property];

          this[property] = Object.extend(ancestor[property].wrap(method), {
            valueOf: function() { return method; },
            toString: function() { return method.toString(); }
          });

        }
        else
          this[property] = object[property];
      }
    }
  }

var uri = $U("ftp://billy:bobby@ftp.somewhere.com/path/to/something");
uri.scheme
// => "ftp"
uri.user       
// => "billy"
uri.host     
// => "ftp.somewhere.com"
uri.path      
// => "/path/to/something"
uri == $U(uri) 
// => true
uri.user = 'robert';
uri.path = '/other/place';
uri.scheme = 'http';
uri.toString();
// => "http://robert:bobby@ftp.somewhere.com/other/place"

/*
Copyright (c) 2007 Samuel Lebeau

this piece of software is largely inspired by
 http://download.dojotoolkit.org/release-0.4.2/dojo-0.4.2-ajax/src/uri/Uri.js

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 URI = Class.create({
  initialize: function(uri) {
    var r = uri.match(this.constructor.uriPattern);
    if (!r) throw this.constructor._invalidURIError(uri);
    this._uri = uri;
    this.scheme = r[2] || (r[1] ? '' : null);
    this.authority = r[4] || (r[3] ? '' : null);
    this.path = r[5];
    this.query = r[7] || (r[6] ? '' : null);
    this.fragment = r[9] || (r[8] ? '' : null);
    if (this.authority) { 
      r = this.authority.match(this.constructor.authorityPattern);
      this.user = r[3] || null;
      this.password = r[4] || null;
      this.host = r[5];
      this.port = parseInt(r[7]) || null;
    }
  },

  toString: function() {
    return (this.scheme ? this.scheme + '://' : '') +
           (this.user ? this.user + (this.password ? ':' + this.password : '') + '@' : ''  ) +
           (this.host ? this.host + (this.port ? ':' + this.port : '') : '') +
           this.path +
           (this.query ? '?' + this.query : '') +
           (this.fragment ? '#' + this.fragment : '');
  }
});

Object.extend(URI, {
  parse: function(uri) {
    return new this(uri);
  },

  from: function(object) {
    return (object.constructor == URI) ? object : URI.parse(object.toString());
  },

  uriPattern: new RegExp("^(([^:/?#]+):)?(//([^/?#]*))?([^?#]*)(\?([^#]*))?(#(.*))?$"),

  authorityPattern: new RegExp("^(((?:([^:]+):)?([^@]+))@)?([^:]*)(:([0-9]+))?$"),

  _invalidURIError: function(uri) {
    this.name = 'InvalidURIError';
    this.message = 'Invalid URI : ' + uri + '';
  }
});

var $U = URI.from;

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 + ''; 
  }
}