In this example, we’re using three of these features together to create a very simple version of our fibonacci function.

• Multiple function clauses – In erlang, you can define a function multiple times – and depending on the arguments passed to the function the correct version of that function is executed.
• Pattern matching – To determine which function clause is executed, variables declared in the head can be matched against a pattern. In this example, we’re using the same variable name in the first clause for the third and fourth variables. Because variables are immutable, they can only ever equal one value when they are set. That means that when we are looking for “Count” twice in the function head – we are really looking for those variables to contain the same value.
• Tail recursion – Instead of for or while loops, erlang uses a mechanism called tail recursion. By calling itself multiple times with incremented values, our fibonacci function is in effect executing a loop; and because we have multiple function clauses, we can end the loop when a certain condition is met.

#!/usr/bin/env escript
%% -*- erlang -*-
%%! -smp enable -sname fibonacci debug verbose

%% I've written this as an escript rather than something that we need to compile
%% This means it will compile on the fly and execute the function named main
main([]) ->
	%% Getting the input here is simple a single call to an io function
	Num = io:get_line("\nHow many numbers of the sequence would you like?\n"),
	%% Erlang does have types - we need to remove the newline and convert the
	%% input to an integer here before passing it to the fibonacci function
	fibonacci(0, 1, list_to_integer(string:strip(Num, both, $\n)), 0);
main([Num]) ->
	fibonacci(0, 1, list_to_integer(string:strip(Num, both, $\n)), 0).


%% Here we see the elegance of erlang's tail recursion and multiple function
%% definitions. Rather than changing variables (which we can't do anyway - 
%% they are immutable!), we call the function again with new values. When
%% the end is reached ( Num == Count ), we exit with ok. Notice that the end
%% clause is first so it is exectued when the 3rd and 4th arguments match.
fibonacci( _, _, Count, Count ) ->
	ok;
fibonacci( A, B, Num, Count ) ->
	io:format("~w~n", [A]),
	fibonacci( B, A + B, Num, Count + 1).

One of the biggest new changes to 5.3 is late static binding. It has never been possible in PHP to get the name of the calling class when you called a static method inherited from a parent. Now with late static binding, this is possible. This is what works the “magic” in this base class.

The Assumptions

Models represent an entity stored in the database (think active record):

• In one table per class named the same as the model class, but all lower case
• With one column for each property
• With a primary key column named ‘id’

In addition, a global variable $db should contain a PHP PDO object.

The Base Class

One of the things I’d like to be able to do is create an object from an array of parameters, whether they come from a database or not. I might want to create from a set of parameters and be able to act on it immediately, without having to reload it. I use reflection here to ensure that all the class properties are set, throwing an exception if any are missing.

Note also in the get and getAll methods, the calls to new static(). What this does is create an object of the class you are calling, rather than the class that the method exists in. This wasn’t possible until PHP 5.3, and is really the key to being able to use static inheritance.

In addition, there is a lambda function in the save method, this is new to 5.3 also. And there are a few examples of a new php function “get_called_class()” which will return the name of the class that was called.

<?php
/**
 * Base class for all models
 *
 * @author Zachary Fox
 */
abstract class Base
{
    /**
     * Pass properties to construct
     *
     * @param mixed[] $properties The object properties
     * 
     * @throws Exception
     */
    protected function __construct(Array $properties)
    {
        $reflect = new ReflectionObject($this);

        foreach ($reflect->getProperties() as $property) {
            if (!array_key_exists($property->name, $properties)) {
                throw new Exception("Unable to create object. Missing property: {$property->name}");
            }

            $this->{$property->name} = $properties[$property->name];
        }
    }


    /**
     * Get all class properties
     *
     * @return string[]
     */
    protected static function getFields()
    {
        static $fields = array();
        $called_class  = get_called_class();

        if (!array_key_exists($called_class, $fields)) {
            $reflection_class = new ReflectionClass($called_class);

            $properties = array();

            foreach ($reflection_class->getProperties() as $property) {
                $properties[] = $property->name;
            }

            $fields[$called_class] = $properties;
        }

        return $fields[$called_class];
    }


    /**
     * Get the select statement
     *
     * @return string
     */
    protected static function getSelect()
    {
        return "SELECT " . implode(', ', self::getFields()) . " FROM " . strtolower(get_called_class());
    }


    /**
     * Save this object
     *
     * @return void
     */
    protected function save()
    {
        global $db;

        $fields   = self::getFields();
        $replace  = "REPLACE INTO " . strtolower(get_called_class()) . "(" . implode(',', $fields) . ")";

        $function = function ($value) {
            return ':' . $value;
        };

        $replace .= " VALUES (" . implode(',', array_map($function, $fields)) . ")";

        $statement = $db->prepare($replace);

        foreach ($fields as $field) {
            $statement->bindParam($field, $this->$field);
        }

        $statement->execute();
    }


    /**
     * Get a single object by id
     *
     * @param integer $id
     * @return Object
     */
    public static function get($id)
    {
        global $db;

        $select    = self::getSelect() . " WHERE `id` = :id";
        $statement = $db->prepare($select);

        $statement->bindParam(':id', $id, PDO::PARAM_INT);
        $statement->execute();

        $result = $statement->fetchAll(PDO::FETCH_ASSOC);

        return new static($result[0]);
    }


    /**
     * Get all objects
     *
     * @return Object[]
     */
    public static function getAll()
    {
        global $db;

        $return = array();
        foreach ($db->query(self::getSelect(), PDO::FETCH_ASSOC) as $row) {
            $return[] = new static($row);
        }

        return $return;
    }


    /**
     * Create a new object
     *
     * @param mixed[] $properties Properties
     * 
     * @return Object
     */
    public static function create(Array $properties)
    {
        global $db;

        $properties['id'] = ($db->query('SELECT MAX(id) FROM ' . strtolower(get_called_class()))->fetchColumn() + 1);
        $object = new static($properties);
        $object->save();
        return $object;
    }


    /**
     * Update an object
     *
     * @param mixed[] $properties Properties
     * 
     * @return void
     */
    public function update(Array $properties)
    {
        foreach ($properties as $key => $value) {
            if (property_exists($this, $key)) {
                $this->$key = $value;
            }
        }
        $this->save();
    }


    /**
     * Update a single property
     *
     * @param string $key   Property name
     * @param mixed  $value Property value
     * 
     * @return void
     */
    public function updateProperty($key, $value)
    {
        if (property_exists($this, $key)) {
            $this->$key = $value;
        }
        $this->save();
    }


    /**
     * Delete an object
     *
     * @return void
     */
    public function delete()
    {
        global $db;

        $delete    = "DELETE FROM " . strtolower(get_called_class()) . " WHERE `id` = :id";
        $statement = $db->prepare($statement);
        $statement->bindParam(':id', $this->id, PDO::PARAM_INT);

        $statement->execute();
    }
}
?>

Now, you’ll probably notice that this is an abstract class, meaning that we can’t create any Base objects, but must extend the class. Here is an example of a child class that holds name / value pairs:

<?php
/**
 * Extends the base class
 *
 */
class Extend_Base extends Base
{
    protected $id;
    protected $name;
    protected $value;
}
?>

Once I’ve created the matching db table, I’m ready to get some CRUD done.

Creating an object

To create an object, I simply pass the parameters as an associative array of properties and their values.

<?php
$properties = array(
    'name'  => 'First Object',
    'value' => 'This is the first object'
);

$extend_base = Extend_Base::create($properties);
?>

Getting objects

Getting is simple. Either get by ID or get an array of all the objects. It would be fairly trivial to add a find method.

<?php
// Single object
$extend_object = Extend_Base::get(1);

// All objects
$extend_objects = Extend_Base::getAll();
?>

Updating

You can update multiple parameters at once by passing an associative array as you did in the create method, or update a single parameter by using the updateProperty method and passing the name and value.

<?php
$extend_base = Extend_Base::get(1);

$properties = array(
    'name'  => 'Updated Name',
    'value' => 'Updated value'
);

$extend_base->update($properties);

$extend_base->updateProperty('value', 'Updated value again');
?>

Deleting

<?php
$extend_base = Extend_Base::get(1);
$extend_base->delete();
?>

Download Image Index

Have you ever opened up a apache directory listing page for a directory full of images and been frustrated that all you see is the same little icon next to each one? I bring you Image Index, a firefox plugin that replaces that icon with a thumbnail of the image itself.

To start the selenium RC server, you would typically run this command:

java -jar selenium-server.jar

Which will start it on the default port of 4444. If you want to start it on another port, simply add -port <portnumber> to the command like this:

java -jar selenium-server.jar -port 1234

This command would start the server on port 1234.

Great, now I can start the server on multiple ports, so what?

So here is the good news for those of us in shared development environments. Say you have a windows virtual machine running selenium with your test browser installed. Things get complicated when multiple clients are testing at the same time. Tests can fail unexpectedly, developers begin fighting for time on the test server, and all hell breaks loose. By running multiple servers on different ports, we can avoid the third world war. Everyone can connect at the same time to their personal server, and we have peace and harmony in our testing environment.

Wow, setting up a different port everytime must suck.

Not really. There are many ways that you can automate the process so that it’s completely transparent to your development team. A lot will depend on your environment, but in our case, we created a .bat file that starts the servers in our virtual machine and placed it in the start-up folder.

start "Selenium 4444" /min java.exe -jar selenium-server.jar -port 4444
start "Selenium 4445" /min java.exe -jar selenium-server.jar -port 4445
start "Selenium 4446" /min java.exe -jar selenium-server.jar -port 4446
start "Selenium 4447" /min java.exe -jar selenium-server.jar -port 4447

With this in place, we now have 4 selenium RC servers running at all times. If one or more crashes for any reason, running the batch file again will start any that are missing. The selenium RC server will not start if its port is in use, so only the ones missing will run, and you’ll have them all up and running again.

Ok, what about the client side? I don’t want to have to edit another file in my development environment.

On the client side, we are using phpunit with Testing_Selenium. Of course all of our selenium test classes extend a parent class, so it was easy enough for us to create some dynamic logic there to decide which port to use.

<?php
class SeleniumTestHelper
{
    public function setup()
    {
        $ports = array('user1' => 4444,
                       'user2' => 4445,
                       'user3' => 4446,
                       'user4' => 4447);
	$user = someFunctionThatDeterminesUser();
        define('BROWSER', '*firefox');
        define('URL', 'http://www.example.com');
        define('SERVER', '192.168.0.2');
        define('PORT', $ports[$user]);
        $this->selenium = new Testing_Selenium(BROWSER, URL, SERVER, PORT);
    }
}
?>

<?php
/**
 * mail.php
 *
 * A (very) simple mailer class written in PHP.
 *
 * @author Zachary Fox
 * @version 1.0
 */

class ZFmail{
    var $to = null;
    var $from = null;
    var $subject = null;
    var $body = null;
    var $headers = null;

     function ZFmail($to,$from,$subject,$body){
        $this->to      = $to;
        $this->from    = $from;
        $this->subject = $subject;
        $this->body    = $body;
    }

    function send(){
      $this->addHeader('From: '.$this->from."\r\n");
        $this->addHeader('Reply-To: '.$this->from."\r\n");
        $this->addHeader('Return-Path: '.$this->from."\r\n");
        $this->addHeader('X-mailer: ZFmail 1.0'."\r\n");
        mail($this->to,$this->subject,$this->body,$this->headers);
    }

    function addHeader($header){
        $this->headers .= $header;
    }

}
?>

Usage

Using the mail class is easy. Simply create a new ZFmail object, passing the parameters $to,$from,$subject, and $body, then call the method send on the object that you created. It’s as easy as pie. The following example is for a simple form mail script.

Example

<?php
/**
 * example/mail.php
 *
 * An example script to accept a post and send an email using ZFmail.
 *
 * @author Zachary Fox
 */

 // Include the mail.php file that holds the class definition
 require_once('mail.php');

 // First we set the to address. I would not let anyone put in a to 
 // address in a web form, and neither should you.
 $to = 'me@example.com';

 // Then we get the information we need from the $_POST array.
 // This step is not necessary, but in a production environment, 
 // we would process and sanitize this data here, rather than 
 // passing raw post data to the class.
 $from = $_POST['from'];
 $subject = $_POST['subject'];
 $body = $_POST['body'];

 // Then create the ZFmail object using the information from above
 $mail = new ZFmail($to,$from,$subject,$body);

 // Finally, call the object's send method to deliver the mail.
 $mail->send();
?>

Download Vim Color Improved

It uses the same tag and parameter parsing as the popular codeviewer 1.4, and should be compatible with it’s options. In addition, any of the optional parameters from codeviewer 1.4 can be set as defaults, which can then be overriden by parameters in the tag. Vim Color Improved outputs code in <pre> formatted blocks, rather than ordered lists, which can be difficult to copy and paste, and can syntax highlight any language which vim supports.

Vim Color Improved contains a sophisticated caching system that stores the generated html to the filesystem. This greatly reduces the time required to display the code. In addition, it checks the modified time on both local and remote files to ensure that cached information is up-to-date. If it is unable to access the source code, and there is a cached version available, it will display the cached version with a notice.

Using Vim Color Improved

(These instructions basically parallel those for CodeViewer 1.4)

Vim Color Improved searches your post for a custom tag named [viewcode ] [/viewcode], that tells the server to look at an external file and parse it into syntax higihlighted html. It can be placed anywhere a block-level tag is valid but the tag must be properly closed.

Note that there should not be a white space character after viewcode and before ].

Parameters
[viewcode ] src=”URI or path to local file” link=yes|no lines= scroll=yes|no scrollheight=valid css height showsyntax=yes|no cache=yes|no[/viewcode]

Default values for all of these parameters, other than src can be set in the options page.

The src attribute is required.
src – string – The URI or path to a local file of the code to display. Note that relative paths are in relation to the default_path set in the options page. This default value is set to the directory your blog is installed in.

The link attribute is optional.
link – string – Should the link to the code be displayed (yes), or not be displayed (no). If the link attribute is left out of the tag completely, the value defaults to no.

The lines attribute is optional.
lines – string – Which line numbers shall be visible in the output. Use , and – to separate line numbers. Example: lines=1,3-5,10-12,16-18,22.

The scroll attribute is optional.
scroll – string – Should the scrollbar be displayed (yes), or not be displayed (no).

The scrollheight attribute is optional.
height- string – Height of the scrollbar. Any valid css height declaration can be used. Example: 100px or 50em

The showsyntax attribute is optional.
showsyntax – string – Should the syntax used of [viewcode ] be displayed (yes), or not be displayed (no).

All attribute values can optionally be surrounded with double quotes (“) or single quotes(‘).

Installation

1. Download Vim Color Improved
2. Unzip the archive and copy the entire vim-color-improved folder to the wp-content/plugins directory
3. Vim Color Improved needs a directory to store the cached files and to use as a temp directory. Please make sure that your web server can write to and read from the vim-color-improved/tmp directory.
4. Activate the plugin from the Plugins page in your WordPress administration console.
5. Vim Color Improved also provides an options page for you to set the default options. While the plugin will work without any intervention, you may wish to review these at (Options->Vim Color Improved. You may also see a list of cached files and clear the cache there.

Frequently Asked Questions

Why are there no FAQs?

This is the first release.

Example

Here is an example of Vim Color Improved in action. We can see here the parameters that were passed in the tag by looking at the showsyntax block above the html code block.

[viewcode]src=http://www.zacharyfox.com/blog/wp-content/plugins/vim-color-improved/css/vci-style.css cache=yes showsyntax=yes[/viewcode]

pre.vci_code{
	background:#333;
	color:#fff;
	padding:5px;
	font-size:12px;
	margin-bottom:0;
	margin-top:0;
	overflow-x:auto;
}

pre.vci_code .c14 { color: #ff40ff; }
pre.vci_code .c26 { color: #8080ff; }
pre.vci_code .c27 { color: #ff6060; }
pre.vci_code .c28 { color: #ff40ff; }
pre.vci_code .c30 { color: #ffff00; }
pre.vci_code .c31 { color: #ff40ff; }
pre.vci_code .c32 { color: #00ff00; }

pre.vci_code .Constant { color: #ff6060; }
pre.vci_code .Identifier { color: #00ffff; }
pre.vci_code .Statement { color: #ffff00; }
pre.vci_code .PreProc { color: #ff40ff; }
pre.vci_code .Type { color: #00ff00; }
pre.vci_code .Comment { color: #8080ff; }
pre.vci_code .Special { color: #ff40ff; }

p.vci_info, p.vci_warning{
	background:#eee;
	color:#666;
	font-size:80%;
	padding:3px;
	margin-top:0;
	margin-bottom:0;
	text-align:right;
}

p.vci_warning{
	background:#fee;
	font-weight:bold;
	text-align:left;
}

HTML code generated by vim-color-improved v.0.4.0.Download this code: vci-style.css

Requirements

This plugin may not work on all php installations. Specifically, there are some access needs that may be locked down on your web server.

1. Your web server must be able to exec(vim) through php
2. If you want to use remote files, your web server must be able to open the files through http using file()

To Do List

1. Add the ability to use vim’s options, such as using css, using xhtml, etc…
2. Add the ability to use WYSIWYG editor for posts, including file selection box for local files.

Version History

v.0.4.0 Bug fixes and new features

• Fixed problem with files not being found not displaying an error
• Fixed vim command, was missing last quit
• Added vcihtmluse_css parameter and option
• Added vim classes to style.css
• Refactoring of vci_color(), created new methods to decrease the main method size
• Added vci_link for a default value
• Added more vim options to the vim command to help performance
• Added functions.php to include additional functions not directly related to vci
• Moved temporary directory to the system temp dir to ease installation – no longer need to chmod a directory
• Attempt auto-detect of vim path using exec(‘which vim’)
• Added admin css, moved css files to css directory
• Added management page for cache management
• Added ability to clear single files from the cache
• Changed to scroll horizontally by default if code is too wide

v.0.3.2 First Public Version

License

Copyright 2008 Zachary Fox (email : ecommerceninja at gmail dot com)

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA

/*
 * Much like C's stdio.h, the java.io.* classes will let us access stdin and stdout.
 */

import java.io.*;

/*
 * Like Ruby, in java, everything is an object. To write a program, you'll need to
 * start by declaring a class. As in C, our program execution starts with the main
 * function. Also like C, Java is a compiled language, so you'll need to compile 
 * the code and then run the class using the java interpreter.
 */

class Fibonacci {

  /*
   * So here we are defining the main function. Remember that this is supposed to
   * actually run this program, so the function needs to be `public`, in addition,
   * it's `static`, meaning we can call this method without an object of the Fibonacci
   * class being instantiated, and it doesn't need to return anything, as it will
   * run by the interpreter, which will handle the exit status. 
   */

  public static void main(String args[]) {

    /* 
     * We are using System.out.println here, but newer versions of Java have the printf method.
     */

    System.out.println("How many numbers of the sequence would you like?");

    /*
     * I'm sure there's more than one way to skin a cat, but to read stdin here, we
     * are creating a new BufferedReader, which will read one line of input.
     */

    InputStreamReader sr = new InputStreamReader(System.in);
    BufferedReader br    = new BufferedReader(sr);

    /*
     * Now here is a concept we haven't addressed yet. The java compiler complains if
     * you try to call a method that could throw an exception (error), so I've included
     * an example here of how to handle the exceptions that could be thrown. Also, like
     * in our previous examples, we are casting the input to an integer.
     */

    try {
      String input = br.readLine();
      int n = Integer.valueOf(input).intValue();
      fibonacci(n);
    } catch (NumberFormatException e){
      System.out.println("That is not an integer. Please enter an integer value");
    } catch (IOException e) {
      System.out.println("I did not recieve an input");
    }
  }

  /*
   * So here is our Fibonacci function. like the main function, it is public and can be
   * called without creating a Fibonacci object. We've also introduced a new method of 
   * calculating the sequence without using a temporary variable. In a later post, I will
   * examine the different algorithms used to calculate the Fibonacci sequence, and compare
   * performance in multiple languages.
   */

  public static void fibonacci(int n){
    int a=0,b=1;

    for (int i=0;i<n;i++){
      System.out.println(a);
      a=a+b;
      b=a-b;
    }
  }
}

• Fibonacci in C
• Fibonacci in PHP
• Fibonacci in BASH
• Fibonacci in Perl
• Fibonacci in Python

So this is our sixth version of the simple sequence generator, this time in Ruby

#!/usr/local/bin/ruby

# In Ruby, we define a function with def...end functions can accept parameters,
# but don't have to, and you can leave off the parenthesis if your function does
# not need them.

def main
  printf "\nHow many numbers of the sequence would you like?\n"

  # Here, STDIN is a constant, but like everything in Ruby, it's also a class, so
  # we use the readline method to get our input. to_i casts our input to an integer

  n = STDIN.readline.to_i
  fibonacci(n)
end

# Here is a good example of something that is cool about Ruby. The times method
# works just like it sounds, it will do something n times. As in Perl and Python,
# we don't need a temp variable here to swap the values for a and b.

def fibonacci(n)
  a,b = 0,1
  n.times do
    printf("%d\n", a)
    a,b = b,a+b
  end
end

main

The next installment will be another popular language. Stay tuned to see Fibonacci in Java.

#!/usr/bin/python

# Import the system library. This allows us to access stdin later.
import sys

# Here's our main function. Python is pretty efficient here. You
# should notice that there are no braces. Python is dependant on
# whitespace to define blocks.

def main():
  print "\nHow many numbers of the sequence would you like?"
  n = int(sys.stdin.readline())
  fibonacci(n)

# Here's the fibonacci function. Like in Perl, you can assign multiple
# variables on a line without using a temporary variable. Also, the for 
# loop here works more like a foreach loop by setting a range from 0 to n.

def fibonacci(n):
  a,b = 0,1
  for i in range(0,n):
    print a
    a,b, = b,a+b

main()

#!/usr/bin/perl

# Functions in Perl are called subroutines. Like bash, you don't define the 
# parameters in the function declaration. We'll see how to access the parameters
# when we look at the Fibonacci subroutine below.

sub main {

# Again, the ubiquitous printf function. Apparently a staple of programming
printf "\nHow many numbers of the sequence would you like?\n";

# Once again, we don't need to declare variables before using them.
# Perl's scalar variables, prefaced with $, can be either strings or numbers
# We use <STDIN> to get the data from stdin here

$n = <STDIN>;

# As in PHP, we need to remove the newline at the end

chop $n;

&fibonacci($n);

exit 0;
}

# Except for the first line declaring the subroutine, and the different way that
# parameters passed to the subroutine are passed, this is identical to the PHP version

sub fibonacci {
  $a = 0;
  $b = 1;

  # So now we see the parameter being used here. For clarity, I have written the for
  # loop using $n like the other examples. To set $n using the first parameter passed
  # to the subroutine, I access the scalar variable $_[0], which is the first element
  # of the parameter array @_

  $n = $_[0];

  for ($i=0;$i<$n;$i++){
    printf "%d\n", $a;
    $sum = $a + $b;
    $a = $b;
    $b = $sum;
  }
}

&main;

Any Perl gurus want to critique my work here? Like most of the examples, this is a simplified version, but one that works.