Tag Archives: prototype

Populating Select Boxes with Prototype

Adding removing options from drop downs can be down right annoying, but I came up with a simple prototype function that I think makes it a lot easier.

You just pass your select box object, an object with an enumerable-esque ‘each’ method, and a method for creating the individual options. On the advice of my wonderful co-worker Jim, you can pass an optional 4th argument that lets you maintain the options length. It’s defaulted to 1 in order to preserve the first element in a drop down, which we typically leave blank.

Here’s the function:

// Requires Prototype: http://www.prototypejs.org/
function setDropDown(field, data, method, index) {
  field.options.length = index == null ? 1 : index;
    function(e) {

And here are some quick examples:

To clear a drop down:


To copy items from one drop down to another:

  function(e) {
    return new Option(e.text, e.value);

Quick example using JSON

var json = Object.toJSON( {"COUNTRIES":[{"COUNTRY":"Hong Kong","ID":1},{"COUNTRY":"Japan","ID":2}]} );

  function(e) {
    return new Option( e.COUNTRY, e.ID );

Merging Netflix Accounts with ColdFusion and JavaScript

I wrote a little script using ColdFusion and JavaScript to merge two NetFlix accounts. It’s ugly and cheesy, but it works so I thought I’d share.

Here’s how you do it:

  1. Register for a developer key.
  2. Grab the RSS feed url of the queue you want to merge FROM. This can be obtained by logging into the FROM account and clicking on the “RSS” link in the footer.
  3. Log in to the account that you’d like to merge TO.
  4. Hit this script in the same browser you logged into the TO account with, and make sure you allow pop-ups!
<!--- enter your feed here! --->
<cfset feed = "http://rss.netflix.com/QueueRSS?id=P4806480653914107620156446228102116" />
<!--- enter your consumer key here! --->
<cfset key  = "your-consumer-key-here" />
<cfset href = "http://widgets.netflix.com/addToQueue.jsp?output=json&devKey=#key#&queue_type=disc&movie_id=http://api.netflix.com/catalog/movie/" />

<cffeed action="read" name="queue" source="#feed#" />

<cfset movies = queue.item />
<cfset idList = "" />

<cfloop array="#movies#" index="i">
	<cfset idList = ListAppend(idList,ListLast(i.guid.value,"/")) />

	<script src="http://ajax.googleapis.com/ajax/libs/prototype/"/>
	<--- Pop up a new window, swap the href every second. Told ya it was cheesy! --->
		var popUp = window.open('http://google.com');
		var idList = [#idList#];

		new PeriodicalExecuter(
			function(pe) {
				if (idList.length == 0) {
				} else {
					popUp.location.href = "#href#" + idList.pop();


Note: I don’t know if this allowed by the EULA, or if there even is a EULA…so, use at your own risk!

Implementing Prototype’s Event.observe in Ruby – Take 2

I revisited my Event.observe proof of concept and tidied it up a bit with a little help from stackoverflow.com.

Here’s how it do

This here defines a method to determine which method is currently running. There’s a slicker way to do this in 1.9 and you can read about them both on stackoverflow.com.

module Kernel
  def current_method_name
    caller[0] =~ /`([^']*)'/ and $1

Here’s my actual observer class, named after it’s inspiration.

class Event

  def initialize
    @events = []

  def observe object, method, callback
    handle   = Handle.new self, object, method, callback
    @events << handle

  def delete handle
    @events.delete handle

  def call object, method
    handle = Handle.new self, object, method
    @events.each do |e|
      e.call if e.shares_type_with 


And finally there's a basic handle class:

class Handle

  attr_reader :observer, :object, :method, :callback

  def initialize observer, object, method, callback = nil
    @observer  = observer
    @object    = object
    @method    = method
    @callback  = callback

  def shares_type_with? handle
    object == handle.object && method == handle.method

  def call

  def stop_observing
    observer.delete self

And here's how you use it, In the following example we want our "second" Test_Object to run it's test_method whenever we run the same method for our "first" object.

The important thing here is the "notify" method, you'll need to drop this method into whatever you'd like to be able to observe. If you wanted to be able to observe everything you could always loop through the methods, alias and override.

class Test_Object

  def initialize observer, label
    @observer = observer
    @label    = label

  def notify method
    @observer.call self, method

  def test_method
    puts "Calling => #{@label}"
    notify current_method_name 


observer = Event.new

first    = Test_Object.new observer, "First"
second   = Test_Object.new observer, "Second"

h1  = observer.observe(
  second.method :test_method


# Calling First
# Calling Second
#=> nil

And we can drop the handle by simply calling it's stop_observing method


# Calling First
#=> nil

That's it.

Download the Proof of Concept!

Implementing Prototype’s Event.observe in Ruby

I love Prototype. I wanted to implement something akin to Event.observe in some of the gui applications I’ve been playing with. The code’s fugly, but it’s a first pass and I just finished my last Netflix.

Example JavaScript Implementation is pretty:

a = new Test_Object( "First" )
b = new Test_Object( "Second" )


  function(e) { new Test_Object("Third").test_method() }

Example Ruby Implementation..not so pretty.

$event = Event.new
a      = Test_Object.new( "First" )
b      = Test_Object.new( "Second" )

  b.method( "test_method" )

  Proc.new { Test_Object.new("Third").test_method }


Yep, that’s a global. I’m still working on it. Any ideas would be welcome!

Download the Ruby code!

JavaScript Deck of Cards Pt 2

A co-worker of mine sent me some advice on the JavaScript deck of cards I set up a while back. Everything he said was spot on. Jim, if you’re out there, you’re insight and advice is always welcome and highly respected. Thanks!

Read your blog. 🙂

In the interest of academic feedback (don’t take any of this in a negative way), I have a few comments.

It’s hard to tell from the current function names, but if the “same_suit” and “same_type” Card methods are meant to be “is_same_…” functions, they you need to change the “=” to “==”.

Card = Class.create({
	initialize: function(type,suit) {
		this.type = type;
		this.suit = suit;
	same_suit: function(suit) {
		return this.suit == suit;
	same_type: function(type) {
		return this.type == type;
	toString: function(){
		return this.type + ' of ' + this.suit;

JS supports the ‘+=’ operator for strings, so you could change the “message = message + …” to “message += …” in the Deck::toString method.

The first time through the Deck::toString function, the modulo check will be true, resulting in message beginning with a ‘n’ character. Wasn’t sure if that is what you wanted.

Here’s a minor optimization for the Deck::toString function. It removes the modulo operation from the loop, which is performed 52 times on a full deck, and handles the all of the leading/trailing whitespace (tabs and newlines) automatically:

toString: function() {
	var message = '';
	var i = 0, n = this.cards.length - 2;
	for(; i < n; ) {
		message += this.cards[i++] + 'tt' + this.cards[i++] + 'n';
	if (i < this.cards.length) {
		message += this.cards[i++];
	if (i < this.cards.length) {
		message += 'tt' + this.cards[i];
	return message;

The following code:

var face_cards = "King,Queen,Jack"
face_cards     = face_cards.split(',');

Could be:

var face_cards = ["King","Queen","Jack"];

I don't think you need the "var i" in the Deck::add_card method.

PS: One other minor update, I got started thinking about UNO and decided to break out the French or Anglo American deck specifications out to a separate class and file.

PPS: Jim caught me using a "=" in place of a "==". These were methods that I hadn't tried yet, but knew that I would need in the future. This is exactly the sort of thing that would have been instantly caught had I written out some tests. I'm a bit late to the game on TDD, but it's something I've been toying with in Ruby and I'm starting to come around. I don't even know where to start unit testing in JavaScript, but I plan on doing a bit of homework on the matter so stay tuned!

Download the code!
JavaScript Deck of Cards V2
Current Version

JavaScript Deck of Cards

I wrote up a basic model for a 52 card deck of playing cards in JavaScript (using beloved Prototype. I plan on using it to make some very simple card games in the near future. I thought it’d be interesting to post this before I actually used it anywhere so I could take a look at how much it changed after I actually implemented it.

There’s not much to see at the moment. You can just shuffle and get a card dump:

        JavaScript Deck of Cards

Download the code!
JavaScript Deck of Cards V1
Current Version

JavaScript Tile Puzzle

I was tinkering a bit while watching the tube tonight and I thought it might be fun to make a simple JavaScript tile puzzle. Might look terrible in other browsers.

First step was to write a little ruby script (using the GD Graphics Library) to read in a file and cut it up into individual tiles. (Photoshop is for wussies)

if __file__ = $0
  #pass the image name, tile size through the command line
  t = Tile_Cropper.new ARGV[0], ARGV[1].to_i

Then I used a slightly modified method I read about in Ben Nadel’s blog to scramble the tiles.


A little bit of CSS magic:

#puzzle {
	width:      500px;
	margin:     0px;
	padding:    0px;
.piece {
	list-style: none;
	display:    inline;
	margin:     0px;
	padding:    0px;
img {
	border:     1px solid gray;

And finally I used scriptaculous and prototype for the obnoxious drag-and-drop sorting. Not that I’m complaining. the Sortable methods weren’t intended to be used for something like this.

function init() {

Complete the puzzle to find out what I was watching!. Here, I’ll give you a hint. It’s Dexter.

Download the code.

JavaScript Game Of Life Pt 2

I changed up the code up a little bit for implementation of Conway’s Game Of Life. Turns out I had misread the rules a bit. My original code turned all cells on when they had 2 or 3 neighbors, regardless of their current state. That’s how live cells are supposed to work, but dead cells are only supposed to change their state when they have exactly 3 neighbors.

Also I’ve updated my JavaScript objects to use the Prototype Class.create method. As far as I know the method I had been using works in all browsers, but I like Prototypes implementation of constructors and inheritance.

Finally, I increased the number of live starting cells, shrunk the number of boxes and increased the time delay between frames to hopefully grant a better user experience. It probably still looks terrible in Internet Explorer. Once again, that’s what you get.

So check it out and download the code!

PS: You can still download and view the original version if you like.

JavaScript Game Of Life Pt 1

I thought it would be fun to implement Conway’s Game Of Life. I used ColdFusion a bit in my example to ease some typing but the “engine” is all JavaScript. Beloved Prototype is also being used a bit behind the scenes.

So without further ado, here’s a

// set up a game of size 30 x 30

g = new Game_Of_Life(30);

// set some random tiles, note that you
// have way more of these for a size
// 30 board.


// draw inital board


// run the game, 1/25s "frame-rate" 

Click to see a demonstration.

And, as always: Download the code!

PS: It looks like terrible in Internet Explorer. No comment.