From time to time I spend a little too long on a project I probably shouldn’t. A while back I set out to pull in Google News Fast Flip data for my personal Homepage(you’ll see several projects from this). For those who are not famiiar with Google Fast Flip, it is a service that shows screenshots of news articles from several different sources. Now, unusual for Google there isn’t an API for Fast Flip. This would seem to be the end of the story, but if you pay attention to their page you will notice that they pull in the articles via AJAX. So I started with this to try to pull in data. The base URL is http://fastflip.googlelabs.com/data. If you open this URL up you will get nothing. This is because it requires that you to post data to it with a query string, a start, and a number of posts to pull. So lets curl that.

The fun part

Before we start here is a quick example of what you can do with the data: Demo

<?php
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, 'http://fastflip.googlelabs.com/data');
curl_setopt($ch, CURLOPT_POSTFIELDS, "q=section:\"Sci/Tech\"&start=0&num=1");
curl_setopt($ch, CURLOPT_FOLLOWLOCATION, true);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$content = curl_exec($ch);
$response = curl_getinfo($ch);
curl_close($ch);

echo $content;

This will get you what looks like JSON data but will not parse with json_decode(). It looks something like this:

[['06/21/11 00:00','The Atlantic','Forget the Specs, Is the New MacBook Air Going to Be Black?','http://www.theatlantic.com/technology/archive/2011/06/forget\x2Dthe\x2Dspecs\x2Dis\x2Dthe\x2Dnew\x2Dmacbook\x2Dair\x2Dgoing\x2Dto\x2Dbe\x2Dblack/240760/','rLgszGxdkW19xM','Nicholas Jackson','Sci/Tech','','640 956','992 956','http://g1.gstatic.com/news/screenshots/u2yJ66dzwq5X2M\x2Dtiny.png','http://g1.gstatic.com/news/screenshots/u2yJ66dzwq5X2M\x2Dmed.png','http://g3.gstatic.com/news/screenshots/u2yJ66dzwq5X2M.png','1','Nicholas Jackson \x2D Nicholas Jackson is an associate editor at The Atlantic. A former media aggregator for Slate, his writing has also appeared in Encyclopaedia ...','http://www.theatlantic.com/technology/archive/2011/06/forget\x2Dthe\x2Dspecs\x2Dis\x2Dthe\x2Dnew\x2Dmacbook\x2Dair\x2Dgoing\x2Dto\x2Dbe\x2Dblack/240760/','1','3','8797714876515','','','0','']]

On this one I wasn’t quite sure so I have this custom parser (thanks to Matt for the help with the regex):

$page = array_map(function ($n) {
return preg_replace("#^\\[*'?(.*)'?\\]*$#", '$1', preg_split("#','#", $n));
}, preg_split('#\],#', $content));

Update:
Thanks to adbe on reddit, I was able to simplify this a bit with the following chunk of code:

$search = array('\'', '\\');
$replacement = array('"', '\\\\');
$content = str_replace($search, $replacement, $content);

From here you can actually json_decode() the content variable which will give you an array.

What you get from this is an array of 0-22. For me this was the most difficult part. I let this run as a cron for a few days and just dumped everything to a table. To save you a LOT of trouble this is what I found (and didn’t)
Update:
Thanks to one of the Google devs for confirming the fields I didn’t know.

0 – Date Time the article was written
1 – The news source
2 – Article Title
3 – Link to the article
4 – What I think is a Google internal id (As per the Google dev this is an internal id)
5 – Author of the article
6 – Category the post is in (Check below for a full list)
7 – This field is always blank(As per the Google dev this isn’t used)
8 – Medium image dimensions
9 – Large image dimension
10 – Thumbnail image URL
11 – Medium image URL
12 – Large image URL
13 – Always 1 or 0 but I don’t know what it represents (as per the Google dev this is for showing ads)
14 – A snippet of the content
15 – A link to the article, always exactly the same as number 2
16 – Always 1, but again I don’t know what this field represents
17 – Always 1 or 0 but I don’t know what it represents(As per the Google dev this is actually the number of likes but might not be used anymore)
18 – A number but I don’t know what it represents
19 – Always blank
20 – Topics or Tags
21 – A number but I don’t know what it represents (As per the Google dev this is a personalization score)
22 –  Whether the source is Tribune Company, Wenner Media, or its blank

As you can tell I have a few holes in this I would love to fill in. If you can help with this I would be glad to hear what they are. As far as the sections I use the following array:

$sections = array(
'Politics',
'Business',
'U.S.',
'World',
'Sports',
'Sci/Tech',
'Entertainment',
'Health',
'Opinion',
'Travel',
'Environment'
);

Conclusion

Now, this is of course just the starter. I actually loop through all of the sections and store the information I want to my HUD database. What I can tell you from the time I’ve had this running is Google seems to store the images for about a month and then they remove them. I hope this helps someone with a project they are working on and as always I’m interested in your thoughts and how you think this could be used.

It has been pointed out, and I agree, that this should not be used for any sort of production application. When I said that I hoped it helped someone with a project I meant a personal project. I just wanted to clear this up.

This is just a quick guide on creating a modular application structure in the Zend Framework using the Zend Framework Tool (more or less).

The Process

First move to your directory.

cd /var/www/

Now create the project

zf create project MyApp
cd MyApp

Now that we have a functioning app. The next step is to turn it into a modular application. First we remove the controller and view directories then we create our first module with its controller, action, and view.

rm -rf application/controllers/
rm -rf application/views/
rm -rf application/models/
zf create module default
zf create controller Index 1 default

Now that we have our default controller with a index controller and index view, were almost there. The system isn’t yet setup to use the modules so the last thing we need to do is edit the application configuration file. In the application config you will make the following change

; Remove this line from your current application.ini
resources.frontController.controllerDirectory = APPLICATION_PATH "/controllers"
; Add this line in its place
resources.frontController.moduleDirectory = APPLICATION_PATH "/modules"

Conclusion

This is the process that I currently use. I’m sure there is a much easier solution to this but I haven’t found it. Please let me know in comments if you know of a better way.

Most of your work with PDO will center around the PDOStatement class. Of all of the classes in the PDO package this is the one that you will need to know the best. As such I will try to cover the core functions with a little more code then last time. I will not be covering all of the functions in the post as there isn’t much I will be able to expand upon from the PHP docs. My goal is to give you a mid level understanding of the methods and how/when to use them so learning the rest of the methods will be a lot easier for you. For this post I will be writing examples that center around pulling user data for an admin panel like section of a site.

PDOStatement::execute()

The execute method does exactly what it sounds like. It runs the query for its statement. Optionally when escaping parameters while using question marks you will pass them into execute as an array in the order they will be replaced in the query. Lets get right into the example with this one. First we will generate the statement object.

$stmt = $db->prepare('SELECT u.username, u.display_name FROM users u WHERE u.id = ?');

Notice the question mark? This is where PDOStatement will replace the value we tell it to run. By giving the value to PDO, we let PDO escape the value which helps to protect you against SQL injections. To tell PDOStatement which value to put in there we pass it in as an array to the execute function:

$userId = 10;
$stmt->execute(array($userId)); // runs - SELECT u.username, u.display_name FROM USERS u where u.id = 10;

If you don’t have any values to escape you just wouldn’t pass in the array parameter. It should also be noted that the return value of execute is a bool. TRUE if the query was successful FALSE if it wasn’t. The stumble here is it will ONLY return FALSE if the SQL has an error. So if the SQL is valid but return no rowset you will still get a TRUE return value. Keep this in mind when checking the return value.

rowCount

Row count will give you either the number of affected rows, or the number of returned rows depending on your query (Please note that in some systems it will only return affected rows when running DELETE, INSERT, and UPDATE queries. In MySQL running PHP 5.3 it will return the number or returned rows. Just keep in mind YMMV).

$stmt = $db->prepare('SELECT * FROM users WHERE role_id = 1'); // select all admins
$stmt->execute();
echo $stmt->rowCount(); // Echo the number of admins in the database
$stmt = $db->prepare('DELETE FROM users WHERE id = 10');
$stmt->execute();
echo $stmt->rowCount(); // Assuming there is a user with the ID of 10 this will echo 1

Binding input

Binding provides a way to assign values that need to be escaped and inserted into a SQL statement(Like the first question mark example we looked at). When using the methods bindParam or bindValue it expects named place holders. This can make larger queries easier to read. The only difference between bindParam and bindValue is bindParam passes the value you assign by reference and bindValue is not. This works well when you have stored procedures that have input/output values, but this is a topic for later. Lets convert the above example to use named place holders.

$stmt = $db->prepare('SELECT u.username, u.display_name FROM users u WHERE u.id = :userId');
$stmt->bindValue(':userId', 10);
$stmt->execute(); // Runs the same query as above.

Note that if you convert the above example to use bindParam it will throw a warning because you cannot pass a value by reference. Just keep this stumbling block in mind when writing your queries

Fetching data

So after all that lets finally get our data! PDOStatement provides a few different ways to fetch the data from your query. We will cover them one at a time

fetch

I think its fairly obvious just from the name what this does, so I wont say to much about it. I will note that once you use this function it moves on to the next result in the row set. If there isn’t another row it will return FALSE.

$stmt = $db->prepare('SELECT * FROM users WHERE role_id = 1'); // select all admins
$stmt->execute();

while($row = $stmt->fetch()) {
    echo $row['username'].'
'; // Just echo out the username in a list
}

The fetch method takes a few params but I will only cover the first. This param tells the method in what way to return the row values. By default it returns an array that includes numbered keys as well as keys with column names. In most cases you will use one or the other but not both. Lets look at some examples:

// ... build and execute statement
while($row = $stmt->fetch(PDO::FETCH_ASSOC)) {
    // This one will work exactly as above the returns row just will not have numbered keys
    echo $row['username'].'
'; // Just echo out the username in a list
}

// Option 2: fetch stdClass
while($row = $stmt->fetch(PDO::FETCH_OBJ)) {
    echo $row->username .'
';
}

// Option 3: this is the same as option 2 just using a built in PDOStatement method
while($row = $stmt->fetchObject()) {
    echo $row->username .'
';
}

PDOStatement has some other options for fetching types that we will cover in a little more advanced post.

Fetching EVERYTHING

The final option is to pull all the rows at once in an array. You do this through the fetchAll method. Again you can tell this method how to return the rows.

// ... build and execute statement
$rowSet = $stmt->fetchAll(); // This will give you an array of arrays
$rowSet = $stmt->fetchAll(PDO::FETCH_OBJ); // This will give you an array of stdClasses

Conculsion

I think we have covered quite a bit for this post and this is a good place to stop. The sad part is there is still quite a bit with building and executing queries to cover. I just don’t think its smart to try to do it all in one post. Feel free to ask questions about the topics I covered here. Also let me know if you think I should have covered anything that I didn’t.

Introduction

Through my time in development, I’ve used several database solutions, but to be honest the easiest solution for me has always been PDO. It provides powerful solutions while not getting in your way. On top of this it doesn’t have the large learning curve that comes with many of the other full blown solutions.

In this post we will cover the extreme basics of using PDO. We will be covering the database object itself from connecting to the different ways to run queries. In future posts we will cover the other topics we don’t have room for in this post.

DSN

The first part to connecting to your database instance is a DSN. This is the connection string that will tell PDO to connect to your database. Your DSN will change depending on the type of database you are connecting to but in this post I will be giving MySQL examples. Your DSN will include at minimum type, host, and database name.

// Basic MySQL DSN
$dsn = 'mysql:host=localhost;dbname=test';

This will connect to localhost and the test database. The last option (should you need it) is the port number:

// Basic MySQL DSN
$dsn = 'mysql:host=localhost;dbname=test;port=3306';

Now lets connect to the database. When constructing the PDO class you pass in the DSN we just built, along with a username and password. Optionally the constructor takes a file parameter include driver options. This a little more of an advanced topic we will cover later. For now lets just work on connecting to the database:

// Define DSN, username and password
$dsn          = 'mysql:host=localhost;dbname=test';
$username = 'testingUser';
$password  = 'testingPass';

// We try catch to stop app failures
try {
    $db = new PDO($dsn, $username, $password);
} catch(PDOException $e) {
    /**
     * Handle exception here
     */
}

This is a simple example on creating a database connection, but in most cases this will be enough for your project. Lets move on to actually working with the database.

Querying the database

For querying the database you have 3 options that we will cover 1 at a time.

PDO::exec()

The exec function is used exclusively for database calls that don’t have a result row set. This would include inserts, creating or modifying tables, and procedure calls that don’t have row sets. As a side note you shouldn’t use exec if you have data that needs to be sanitized (Solutions for this will be covered in a bit). Lets look at a simple example:

// ... Code from above for connecting to the database
$password = hash('sha512', 'superAdminPassword');
$rowCount = $db->exec("INSERT INTO users(username, password) VALUES('admin', '$password')");
echo "Inserted $rowCount rows";

Again this is a simple example but it covers most use cases. Just remember this function shouldn’t be used for data that needs sanitized.

PDO::query()

PDO::query allows you to run a query against the database that returns a row set. I will note here that I prefer to use the prepare function that is covered later. As with exec this function shouldn’t be used if you have user data to escape. The query function works pretty much like the exec function with exception of the return value. With the query method you will get a PDOStatement return value with your data in it, or a false return value on a failed query(Either no result set or SQL error). Lets look at a simple example:

$result = $db->query('SELECT username FROM users');
foreach($result as $row) {
    echo $row['username'].'<br />'; // Output all usernames from the database.
}

PDO::prepare()

I saved this method for last because it deserves (and will probably get) its own post. You will more then likely use this post more then any other one. This is the function that will allow you to escape user data and store a query to run multiple times. Again for this post we are going to cover a very simple example and cover the functionality of PDOStatements further in a future post. Lets look at inserting multiple users:

$stmt = $db->prepare('INSERT INTO users(username, password) VALUES(?, ?)');
$users = array(
    'testUser1' => hash('sha512', 'password1'),
    'testUser2' => hash('sha512', 'password2')
);

foreach($users as $username => $password) {
    $stmt->execute(array($username, $password));
}

Conclusion

This concludes the basic functionality you get from PDO. I hope it gives you enough of a grasp of the class to get you started. Check back for more advanced usage of the classes that surround PDO. As always if you have questions or comments I would love to hear them

First I added JavaScript like loading of the functions, this

$test1 = new Prototype('DateTime');
$test1->setDate = function() use($test1) {
    $args = func_get_args();
    $args[0]++;
    $test1->parentCall('setDate', $args);
};

Now we assign it to a variable:

$func = $test1->setDate;
$func(2011, 4, 21);
echo $test1->format('Y-m-d'); // 2012-04-21 since our expansion increments the year

// But it still works from the object itself
$test1->setDate(2021, 4, 21);
echo $test1->format('Y-m-d'); // 2022-04-21

Finally assigning non-extended functions to variables

$func2 = $test1->format;
echo $func2('Y-m-d'); // 2022-04-21

So I think the class is really shaping up. It still needs work and I’m still interested in your ideas, so feel free to let me know.

Here is the class itself now on BitBucket

So its been a while. Change of job, new babies, and other random events have filled my time. I think I’m ready to start blogging again and I’m hoping that this one really interests everyone.

The one thing I like the most about JavaScript is prototyping. It kind of annoys me that PHP doesn’t have this function, but there isn’t really anything we (non-core developers) can do about that. I have come up with a class that allows for a SEMI prototyping solution. Now I have seen elsewhere that people have put together a class that will let you add closures and use them as functions but this isn’t really prototyping as you cannot modify existing class methods. So this solution is something that I whipped up in about 30 minutes, and I’m very interested in people tweaks, and suggestions. Here’s how it works…

Basic loading for building a class on the fly

$test1 = new Prototype();
$test1->prototype('testingFunction', function() use($test1){
    echo 'Hi!';
});
$test1->testingFunction(); // Echos Hi!

Now lets actually extend a class that exists. Here we will extend a method of the class but then call it right after our extension.

$test2 = new Prototype('DateTime');
$test2->prototype('setDate', function() use($test2) {
    echo 'Hi!2';
    $test2->parentCall('setDate', func_get_args());
});

simple right?

Okay enough examples… Here is the class itself.

<?php
/**
 * Mock prototyping setup for PHP
 *
 * @author    Christian South [christian (at) nopantssoftware (dot) com]
 * @category  Prototype
 * @license   New BSD License
 * @copyright Copyright (c) 2011 No Pants Software
 */
class Prototype
{
    /**
     * Extended Class
     * @var mixed
     */
    protected $_extendedClass;

    /**
     * Extension methods
     * @var array
     */
    protected $_extensions = array();

    /**
     * Call function
     *
     * @param string $functionName
     * @param array $args
     * @return mixed
     */
    public function __call($functionName, $args)
    {
        if(isset($this->_extensions[$functionName])) {
            return call_user_func_array($this->_extensions[$functionName], $args);
        } elseif(method_exists($this->_extendedClass, $functionName)) {
            return call_user_func_array(array($this->_extendedClass, $functionName), $args);
        }

        throw new Exception('Unable to find method: '.$functionName);
    }

    /**
     * Class Constructor
     *
     * @param mixed $className
     * @return void
     */
    public function __construct($className = null)
    {
        if(null !== $className) {
            if(is_string($className)) {
                $this->_extendedClass = new $className();
            } else {
                $this->_extendedClass = $className;
            }
        }
    }

    /**
     * Call a parent function
     *
     * @param string $functionName
     * @return mixed
     */
    public function parentCall($functionName)
    {
        $args = func_get_args();
        array_shift($args);
        return call_user_func_array(array($this->_extendedClass, $functionName), $args[0]);
    }

    /**
     * Add extension Method
     *
     * @param string $functionName
     * @param Closure $function
     * @return Prototype
     */
    public function prototype($functionName, Closure $function)
    {
        $this->_extensions[$functionName] = $function;
        return $this;
    }
}

Again, I’m interested in every ones thoughts on tweaks and expansions on this. And even things that you see wrong.

Usage is is fairly simple and is as follows:

$benchmark = \IMorf\Benchmark::getInstance();
$benchmark->startTimer('fullLoad');
$benchmark->startMemoryTracker('fullLoad');
/**
 * Lots and Lots of code here
 */
$benchmark->startTime('someOtherTime');
/**
 * More code
 * and at the end or wherever you want to echo
 */
echo $benchmark->getTimer('someOtherTime');
echo $benchmark->getTimer('fullLoad');
echo $benchmark->getMemoryTracker('fullLoad');

Its a fairly simple class but provides for tracking different elements of your application on the fly. Here’s the code I will be using. If you have any questions let me know.

<?php
/**
 * iMorf PHP Framework - Morphing PHP one line at a time
 *
 * LICENSE
 *
 * This source file is subject to the new BSD license that is bundled with
 * this package in the file LICENSE.txt. It is also available through the
 * world-wide-web at this URL:
 * {@link http://www.imorf.com/license/new-bsd}
 * If you did not receive a copy of the license and are unable to obtain
 * it through our website, please send an email to license@imorf.com
 * so we can send you a copy immediately.
 *
 * @category   iMorf
 * @package    Benchmark
 * @copyright  Copyright (c) 2010 Xistins Technologies {@link http://www.xistins.com}
 * @author     Christian South [csouth (at) xistins (dot) com] {@link http://www.christiansouth.com}
 * @version    v0.0.1d
 */
namespace IMorf;

/**
 * Base Benchmark
 * Inspiration from Jay Gilford {@link http://www.jaygilford.com/php/simple-timer-class-for-benchmarking/}
 *
 * @category   iMorf
 * @package    Benchmark
 * @copyright  Copyright (c) 2010 Xistins Technologies {@link http://www.xistins.com}
 * @author     Christian South [csouth (at) xistins (dot) com] {@link http://www.christiansouth.com}
 * @version    v0.0.1d
 */
class Benchmark
{
    /**
     * Singleton Instance
     * @var iMorf\Benchmark
     */
    protected static $_instance = null;

    /**
     * All application timers
     * @var array
     */
    protected $_timers = array();

    /**
     * All application memory trackers
     * @var array
     */
    protected $_memoryTrackers = array();

    /**
     * All times left
     * @var array
     */
    protected $_times = array();

    /**
     * All application memory trackers
     * @var array
     */
    protected $_memory = array();

    /**
     * Return all memory trackers
     *
     * @return array
     */
    public function getAllMemoryTrackers()
    {
        foreach($this->_memoryTrackers as $memoryName => $memory) {
            $this->stopMemoryTracker($memoryName);
        }

        return $this->_memory;
    }

    /**
     * Return all times
     *
     * @return array
     */
    public function getAllTimes()
    {
        foreach($this->_timers as $timerName => $time) {
            $this->stopTimer($timerName);
        }

        return $this->_times;
    }

    /**
     * Singleton Instance
     *
     * @return iMorf\Benchmark
     */
    public static function getInstance()
    {
        if(null === self::$_instance) {
            self::$_instance = new self;
        }

        return self::$_instance;
    }

    /**
     * Get Memory Tracker
     *
     * @param  string $name Unique memory tacker name
     * @return float
     */
    public function getMemoryTracker($name, $decimals = 2)
    {
        if(isset($this->_memoryTrackers[$name])) {
            $this->stopMemoryTracker($name);
        }

        if(!isset($this->_memory[$name])) {
            throw new Exception("Unable to get memory tracker by the name of $name");
        }

        return number_format(($this->_memory[$name]/1000), $decimals);
    }

    /**
     * Get a time
     *
     * @param  string $name Unique timer name
     * @return float
     */
    public function getTimer($name, $decimals = 3)
    {
        /**
         * Stop Timer if its started
         */
        if(isset($this->_timers[$name])) {
            $this->stopTimer($name);
        }

        if(!isset($this->_times[$name])) {
            throw new Exception("Unable to get time for timer by the name of $name");
        }

        return number_format($this->_times[$name], $decimals);
    }

    /**
     * Start Memory Tracker
     *
     * @param  string $name Unique memory tracker name
     * @return iMorf\Benchmark
     */
    public function startMemoryTracker($name)
    {
        if(isset($this->_memoryTrackers[$name]) || isset($this->_memory[$name])) {
            throw new Exception("A memory tracker by the name of $name already exists");
        }

        $this->_memoryTrackers[$name] = memory_get_usage();
        return $this;
    }

    /**
     * Start Timer
     *
     * @param  string $name Unique timer name
     * @return iMorf\Benchmark
     */
    public function startTimer($name)
    {
        if(isset($this->_timers[$name]) || isset($this->_times[$name])) {
            throw new Exception("A timer by the name of $name already exists");
        }

        $this->_timers[$name] = microtime(true);
        return $this;
    }

    /**
     * Stop Memory Tracker
     *
     * @param  string $name Unique memory tracker name
     * @return iMorf\Benchmark
     */
    public function stopMemoryTracker($name)
    {
        if(!isset($this->_memoryTrackers[$name])) {
            throw new Exception("You don't have a memory tracker by the name of $name");
        }

        $memory = memory_get_usage();
        unset($this->_memoryTrackers[$name]);

        $this->_memory[$name] = $memory - memory_get_usage();
        return $this;
    }

    /**
     * Stop Timer
     *
     * @param  string $name Unique timer name
     * @return iMorf\Benchmark
     */
    public function stopTimer($name)
    {
        if(!isset($this->_timers[$name])) {
            throw new Exception("You don't have a timer by the name of $name");
        }

        $time = $this->_timers[$name];
        unset($this->_timers[$name]);

        $this->_times[$name] = microtime(true) - $time;
        return $this;
    }
}

$startTime = microtime(TRUE);
// Bunch of code goes here
echo 'Runtime: '.number_format(microtime(TRUE)-$startTime, 3);

In most cases this works. But I was looking to track a bit more then load time while testing my upcoming PHP 5.3 framework. So I created a little script that tracks load time, page your visiting, memory used in the script and date and time of visit. Its not very impressive but I figured I would share with everyone in-case your looking for something similar. So with out further ado…

/**
 * Extra Just for Testing
 */
$memStart = memory_get_usage();
$startTime = microtime(TRUE);
/**
 * End of Extra
 */

// All the same code here

/**
 * Extra Just for Testing
 * echos full runtime and memory for this and last request
 */
$memEnd = memory_get_usage();

// Put this here so the file stuff does not scew the memory numbers
$line  = '<br />Runtime: '.number_format(microtime(TRUE)-$startTime, 3);
$line .= ' <br />Memory: '.number_format(($memEnd - $memStart)/1000, 2, '.', ',').'KB';
echo $line;

if(!file_exists('benchmark.log')) {
    $file = fopen('benchmark.log', 'x+');
} else {
    $file = fopen('benchmark.log', 'a');
    fputs($file, "\n");
}
$timeDate = date('m/d/Y H:i:s');
$uri      = $_SERVER['REQUEST_URI'];
$line = str_replace('<br />', '', $line);
fputs($file, "[$timeDate] - [$uri] - $line");
fclose($file);
/**
 * End of Extra
 */

This will echo something similar to:
Runtime: 0.021
Memory: 195.62KB
on your page, but will create a benchmark file to track all of the page loads so you can track what your changes are doing to memory usage and load time. The lines in that file look something like:
[05/14/2010 03:07:39] – [/var/www/imorf/public/] – Runtime: 0.017 Memory: 196.22KB

I hope this helps some of ya’ll out with tracking code changes.

<?php
namespace Aero\Model\Db;

class Record
{
    protected $_adapter;
    protected $_table;
    protected $_tablePrefix;
    protected $_primaryKey = 'id';
    protected $_info = array();
    protected $_originalInfo = array();

    public function __construct($id = 0)
    {
        $this->_adapter = \Aero\Controller\Application::getInstance()->db;
        $this->_getTableInfo();
        if($id !== 0) {
            $this->getRecord($id);
        }
    }

    public function __set($key, $value)
    {
        // If the key isn't there it doesn't belong in the database
        if(!isset($this->_info[$key])) {
            return null;
        }

        $this->_info[$key] = $value;
        return $value;
    }

    public function __get($key)
    {
        if(!isset($this->_info[$key])) {
            return null;
        }

        return $this->_info[$key];
    }

    public function getRecord($id)
    {
        $stmt = $this->_adapter->select()
                               ->from($this->_table)
                               ->where(array($this->_tablePrefix.$this->_primaryKey => $id))
                               ->getStatement()->execute();
        $info = $stmt->fetch();
        foreach($info as $field => $value) {
            $field = str_replace($this->_tablePrefix, '', $field);
            $this->_info[$field]         = $value;
            $this->_originalInfo[$field] = $value;
        }
    }

    protected function _getTableInfo()
    {
        $info = $this->_adapter->getTableFields($this->_table, $this->_tablePrefix);
        foreach($info as $field) {
            $this->_info[$field]         = '';
            $this->_originalInfo[$field] = '';
        }
    }

    public function save()
    {
        if($this->_info == $this->_originalInfo) {
            return true;
        }

        if($this->id !== '') {
            $query = 'UPDATE '.$this->_table.' SET ';
            foreach($this->_info as $field => $value) {
                if($field !== $this->_primaryKey) {
                    $field = $this->_tablePrefix.$field;
                    $value = $this->_adapter->quote($value);
                    $updates[] = "$field=$value";
                }
            }
            $query .= implode(', ', $updates);
            $query .= ' WHERE '.$this->_tablePrefix.$this->_primaryKey.' = '.$this->_originalInfo[$this->_primaryKey];
            if($this->_adapter->exec($query)) {
                return true;
            }
        } else {
            foreach($this->_info as $field => $value) {
                if($field !== $this->_primaryKey) {
                    $columns[] = $this->_tablePrefix.$field;
                    $values[]  = $this->_adapter->quote($value);
                }
            }
            $query  = 'INSERT INTO '.$this->_table.'('.implode(', ', $columns).')';
            $query .= ' VALUES(' . implode(', ', $values).');';
            if($this->_adapter->exec($query)) {
                return true;
            }
        }

        return false;
    }
}

This whole class is not that complex. To use it you would simply extend the class like so:

<?php
class User extends Record
{
    protected $_table = 'users';
    protected $_tablePrefix = 'user_';
}

Then to use it you would simply some something like:

<?php
$user = new User(); // Creates new user
$user->login = 'username';
$user->password = hash('sha512', 'password');
$user->save();

Well I hope this helps someone. I know the class isn’t perfect but again I’m just trying to share.

<a name="anchor1"></a>
...
<a name="Anchor2"></a>

Now to most people this wouldn’t be too much of an issue except when linking to them with the following

<a href="#anchor1">Click Here</a>
...
<a href="#anchor2">Click Here</a>

Now here there is one subtle difference, in the name attribute on the second anchor tag the “a” is capitalized. And here is where it gets a bit fishy. In Internet Explorer and Chrome both of these examples work perfectly. Firefox on the other hand will have a problem with the second. It seems that the anchors are case sensitive in Firefox so it literally looks for an “a” tag with a name of “anchor2,” but all we have is one with a name of “Anchor2.”

The easiest fix for this is to ALWAYS use lowercase names for the anchor names, but we all know asking a client/site user to do this will almost never get you anywhere, so I will recommend the following… REGEX! Simply search the content provided by the user for a name attribute an simply convert it to all lower case. You will of course have to do the same for any tags pointing to that anchor.

In conclusion.. I hate cross browser testing. I can’t really call this a bug due to the fact that I use *nix based systems most of the time and I’m used to case sensitivity, but I would like to see this fixed in Firefox. If anyone has any thoughts please let me know.