• Easy to include in projects without having to change include paths, mess with auto loaders, or include other frameworks
• Something that minimized the amount of validation code that needed to be written, preferably with a fluent interface
• Ability to generate error messages that can be shown to the end user
• Ability to transform data to data types needed by the rest of the script
• Capability to validate against arbitrary regexes
• Capability to validate against closures or other external functions

I couldn’t find exactly what I was looking for, so I decided to write it myself. I added the result, InputValidator, to my gUtils collection of PHP classes on Github. InputValidator is a standalone script for validating user input from forms or other sources.

Everything is in a single file, making it easy to include in any (PHP 5.3+) project. Here’s some example usage:

<?
require('gUtils/InputValidator.php');
// this could be from $_POST
$data = array(
  'name' => 'Greg Neustaetter',
  'email' => 'greg@emailaddress.com',
  'website' => 'http://www.gregphoto.net',
  'favoriteNumber' => 'xyz',
  'date' => '11/11/2011'
);
 
// pass in the data to be validated
$v = new gUtils\InputValidator($data);
 
// validate each field
$v->field('name')->required()->length(3,50);
$v->field('email', 'Email Address')->required()->email();
$v->field('website')->url();
$v->field('favoriteNumber', 'Your favorite number')->intRange(0,100)->toInt();
$v->field('date')->toDateTime('m/d/Y')->after(time()); // after the current time
 
if(!$v->allValid()) {
    echo '<pre>';
    print_r($v->getErrors()); // returns an array of errors indexed by field
    echo '<pre>';
    exit();
} 
$data = $v->getValues();  // returns an array of values indexed by field
$name = $v->get('name'); // get the value of name
echo $v->escape('name'); // escape the value of name for output with htmlspecialchars

This script would print the following error array:

Array(
    'favoriteNumber' => Your favorite number must be an integer between 0 and 100
    'date' => Date cannot be before 12/24/2011
)

In addition to validation the library includes a few filters to manipulate data and cast it to formats needed by your code. Take a look at the documentation on the Github wiki for a list of the 20 validators and the 8 filters.

Let me know if you find it useful or if you have any feedback…

Recently I had the need to find all of the files in a fairly big directory structure that were web pages – in my case, files with the .php and .html extensions. There were hundreds of directories and thousands of files to go through, so I decided to write a php script to find the files and then execute some code on the resulting files.

I abstracted out the code to find files matching a particular extension and have posted the (minimal) code on Github as RecursiveFileExtensionFilteredIterator. The 20 or so lines of code makes use of a couple of PHP’s SPL iterators including the Recursive Directory Iterator, the the Recursive Iterator Iterator, and the Filter Iterator. The result of this is a simple class that allows you to loop through a directory recursively to find only files that match a particular set of extensions, returning a SplFileInfo object for each file. Here’s a simple example that prints out all of the paths:

<?php
require('RecursiveFileExtensionFilteredIterator.php');
 
$path = '/path/to/starting/directory';
$extensions = array('php','html');
$files = new RecursiveFileExtensionFilteredIterator($path, $extensions);
 
foreach($files as $file) {
	echo $file->getPathname() . "\n";
}

that’s it – short and sweet.

I was fixing up an old website I had built to improve the security and as part of that I wanted to improve the way in which passwords were stored, created, and verified for complexity. As part of this I built PasswordHelper, a small PHP library (61 lines of code) described on the overview/download/documentation/example page as follows:

———–

PasswordHelper is a lightweight BSD licensed PHP class that has a number of password related utility functions that make it easy to:

• Securely store passwords by hashing them with the adaptive Blowfish/bcrypt algorithm with random salt values
• Compare user submitted passwords with stored password hashes
• Generate random passwords
• Validate password complexity for length and matches to a configurable set of regular expressions

The library does nothing too complex – it just makes it easy to do common things to help create more secure PHP applications utilizing existing PHP functions through a simpler API. Most of the existing APIs seem a bit…cryptic (ha ha, right?) and there are so many options and algorithms from which to choose. Choosing the ‘wrong’ algorithm for password hashing can lead to big problems, like the ability for hackers to brute force hundreds of thousands of passwords from your database in an hour.

———–

Here’s a quick example of how it is used:

require('PasswordHelper.php');
$pass = new PasswordHelper();
 
// Hash a password with bcrypt and a random salt before storing it in a database
$hash = $pass->generateHash('myP@ssword');
 
// Validate the password against the stored hash on a login attempt
if($pass->compareToHash('myWrongPassword', $hash)) {
	// password matches	
} else {
	// password doesn't match
}
 
// Generate a random password
$randomPassword = $pass->generateRandomPassword();
 
// Validate the complexity of a password
if($pass->checkPasswordComplexity($password)) {
	// password meets requirements	
} else {
	// password doesn't meet requirements
}

Check it out if you need some help with passwords in your PHP application…

For those who don’t know about Defensio, it is a web service for determining whether a comment on a blog or message in an application is spam. To use it, you must first register for an API key. Defensio is very similar to the venerable Akismet (see the article I wrote on Akismet) but they provide a couple other features such an indication of the ‘spaminess’ of an individual message. Akismet has worked out great for me (123,419 spam comments caught so far!), but I figured it would be good to try out something new as well.

The class is a PHP5 class and the public methods are reasonably well commented. The bottom of this post has a link to a test application and a download of the class/test application. So…the usage of this class is quite straightforward, as shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

require('library/Gregphoto/Defensio.php');
require('library/Gregphoto/Defensio/Adapter/Streams.php);
 
$apiKey = 'mysecretapikey';
$siteUrl = 'http://my.secret.site.url.com';
 
$defensio = new Gregphoto_Defensio($apiKey,$siteUrl);
$defensio->setHttpClient(new Gregphoto_Defensio_Adapter_Streams());
 
$params = array(
	'user-ip' => $_SERVER['REMOTE_ADDR'],
	'article-date' => '2007/11/24',
	'comment-author' => 'Big Bad Spammer',
	'comment-type' => 'comment',
	'comment-content' => 'please click links and buy viagra',
	'comment-author-email' => 'bigbadspammer@annoying.com',
	'comment-author-url' => 'http://www.annoying.com'
);
$result = $defensio->audit_comment($params);
if($result['spam'] == 'true') {
	echo "Comment is spam with a spam score of " . $result['spaminess'];
} else {
	echo "Comment is not spam";
}

A couple key points on usage:

• Each Gregphoto_Defensio object requires an Http adapter that it will use to make Http POST requests to the Defensio web service. I originally hardcoded it to use the Zend_Http_Client from the Zend Framework, but figured this could discourage people from using it. Then I wrote up a quick adapter to use PHP’s Http Stream Wrappers, but realized that didn’t work on my Dreamhost account, so I added in an extra one for the Curl extension. In theory I should have added a Gregphoto_Defensio_Adapter_Interface class, but I was lazy and didn’t want to add in an extra file.
• Each Gregphoto_Defensio object can be used to make many requests
• All of the current Defensio API’s are covered by the class. These are covered by the following methods in the Gregphoto_Defensio class:
  • validate_key
  • announce_article
  • audit_comment
  • report_false_negatives
  • report_false_positives
  • get_stats
• Each of these methods takes a single parameter, an associative array of options as defined by the Defensio API. Each API also returns an associative array of response parameters. Two static utility methods Gregphoto_Defensio::getActions (returns a list of defensio methods such as ‘validate-key’) and Gregphoto_Defensio::getActionDetails (returns a list of required parameters, optional parameters, and response parameters for a specific Defensio action) are provided in order to get the details of the input and output parameters.

I created a simple test application which can be used to test Gregphoto_Defensio and all of the APIs provided by Defensio.

Download the Gregphoto_Defensio class and the test application

The class has the following basic features:

• Ability to read JPEG, PNG, or GIF images
• Ability to output JPEG, PNG, or GIF images
• 4 modes of thumbnail creation
  • MAX_HEIGHT – you specify a maximum height and the dimensions are calculated based off of the height
  • MAX_WIDTH – you specify a maximum width and the dimensions are calculated based off of the width
  • BEST_FIT – you specify a maximum height and width and the dimensions are calculated so that the thumbnail
    is as large as possible without exceeding the maximum height or width
  • EXACT – you specify a maximum height and width and these are directly used. Causes distortion if the
    chosen aspect ratio is different from the aspect ratio of the image
• Renders/saves images in their input format by default, but allows changing the format. For example, input a GIF but output a PNG
• Fully documented object oriented code
• Fluent interface for creating thumbnails with a minimal amount of code

The class is licensed under the MIT license, which basically means it can be used and modified by anyone – for personal or commercial use.

You can Download it from the project page on Google Code. You can view examples of it running on my site – the examples are checked into SVN and can be viewed on the project site. You can also view the docs.

Example usage:

1
2
3
4
5
6
7

require('path/to/Gregphoto_Image.php');
$image = new Gregphoto_Image('path/to/sample/image.jpg');
$image->setMaxHeight(200);
$image->setMaxWidth(200);
$image->setJpegQuality(90);
$image->resize(Gregphoto_Image::BEST_FIT);
$image->showThumbnail();

1
2

$image = new Gregphoto_Image('../images/fan.jpg');
$image->setMaxHeight(200)->setJpegQuality(90)->resize()->showThumbnail();

1
2
3
4
5
6
7
8

require('path/to/Gregphoto_Image.php');
$image = new Gregphoto_Image('path/to/image.jpg');
$image->setMaxHeight(200);
$image->setMaxWidth(200);
$image->setJpegQuality(90);
$image->setOutputType(IMAGETYPE_PNG);
$image->resize(Gregphoto_Image::BEST_FIT);
$image->saveThumbnail('path/to/thumbnail.png');

Enjoy!

• Allows you to perform complex validation, such as verifying the uniqueness of a username, or checking something in the database…all without reloading the page
• Allows you to use the same validation routine for both client-side validation and server-side validation
• Reduces the amount of client-side code needed for validation

The JavaScript used in my example requires the Prototype library. My example uses PHP to perform the validation – more specifically, I’ve used several components of the Zend Framework (PHP5 only). The example uses:

• Zend_Controller_* classes including the new RewriteRouter to handle the routing within the application
• Zend_View to handle the output
• Zend_View_Helper_* classes to build form elements
• Zend_Config to read in configuration options
• Zend_Filter to perform several field validations
• Zend_Json to serialize PHP variables/objects to JSON objects

Did I need all of this stuff on the server-side to put together a simple form validation example? Heck no, but when I’m experimenting with new stuff I like to use a lot of new components so I can learn more about them and be prepared for when I actually do need to use all of this fire power. I’ve been following the Zend Framework carefully, so I wanted to use some of the stuff I hadn’t used yet – particularly the controller architecture.

The HTML and JavaScript

Ok, back to how this JavaScript is used. It’s actually really quite simple. First, you need to include the JavaScript files for both Prototype and AjaxFormValidator in the head of your HTML document:

1
2

<script src="/ajaxValidate/static/js/prototype.js"></script>
<script src="/ajaxValidate/static/js/ajaxFormValidate.js"></script>

Next, you add an ‘onSubmit’ handler to the form you’d like to validate – in this case, mine looks like this:

1

<form action="/ajaxValidate/index/success" method="POST" onSubmit="return submitForm(this);">

The form action is set to the page I’d like the script to go to if the validation is successful. The onSubmit calls a custom function that we still need to define. It passes ‘this’ as an argument – the ‘this’ refers to the form element itself.

Now we define the submitForm() function that the onSubmit of the form will call – it looks like the following:

1
2
3
4
5
6

function submitForm(form) {
	validator = new AjaxFormValidator(form,"/ajaxValidate/index/validate");
	validator.errorDisplay = 'inline';
	validator.inlineElem = 'errorDiv';
	return validator.validate();
}

This function first creates a new AjaxFormValidator object, passing it the form element (or the form id) and the url the validation request should be sent to. The next two lines setup the type of error display that should happen. The following error display types are supported:

• alert: The default option. Displays all errors in a JavaScript alert box.
• inline: Displays errors within an element that is defined on the page. You need to set the element name with validator.inlineElem. In this example, errors will be shown in a div with id=”errorDiv”.
• none: errors won’t be shown to the user. The will be available as an array of errors in the errors property of the validator (i.e. validator.errors). If there are no errors the property will be set to false. Once you have the errors you can perform more advanced error handling/display to the user.

Lastly, validator.validate() will send the values in the form, in an HTTP POST, to the validation url you’ve provided (/ajaxValidate/index/validate in this case). If there are no errors the form will be submitted, if there are errors the will be shown (or not shown if you’ve chosen ‘none’ as the errorDisplay).

The PHP

Once the request is sent it will eventually arrive at the server for processing – in this case, through the magic of routing, it is going to end up in my IndexController in the validateAction method. This function is shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

public function validateAction() {
	$errors = $this->getErrors($_POST);
	if(count($errors) == 0) $errors = false;
	echo Zend_Json::encode($errors);
}
</php>
This function calls another method within the IndexController class called getErrors, passing in the entire array of POST arguments (values in the form).  It receives back an array full of error strings.  If there are no errors, it changes the value of the $error variable to false.  Lastly, it uses Zend_Json to convert the PHP array/Boolean into the equivalent JavaScript array/Boolean.  This string is printed and sent back to the client.
 
The getErrors function itself is very straightforward - it just does a couple validations and returns back an array of the errors.
<pre lang="php" line="1">
protected function getErrors($values) {
	$errors = array();
	if(!Zend_Filter::isRegex($values['fname'],'/^[a-z]+[a-z 0-9-_]*$/i')) {
		$errors[] = 'First Name is required and may only contain letters, numbers, and spaces';
	}
	if(!Zend_Filter::isRegex($values['lname'],'/^[a-z]+[a-z 0-9-_]*$/i')) {
		$errors[] = 'Last Name is required and may only contain letters, numbers, and spaces';
	}
	if(!Zend_Filter::isRegex($values['email'],'/^[_a-zA-Z-]+[._a-zA-Z0-9-]+@[a-zA-Z0-9-]+\.[.a-zA-Z0-9]+$/')) {
		$errors[] = 'Email is required and must be a valid email address';
	}
	if(!Zend_Filter::isAlnum($values['password']) || (strlen($values['password']) < 6) || (strlen($values['password']) > 12)) {
		$errors[] = 'Password must consist of only letters and numbers and must be between 6 and 12 characters';
	}
	return $errors;
}

Check it out, in action. And that’s about it – pretty simple, huh?

You can download:

• The JavaScript
• The whole PHP project

Check it out

Google provides sample PHP code for getting the integration going, but unfortunately the code is PHP4 only, and it is ugly ugly ugly code. I decided to put together a simple class that allows simple integration with Google Checkout. The class is PHP5 only because it uses PHP5′s DOM extension.

To use Google Checkout you need to create a Google Checkout account. From there, you can get your merchant id and merchant key, both of which are needed to communicate with Google Checkout. The Google Checkout API works by POSTING XML over HTTP. While Google’s API is very flexible, I’ve chosen to implement a subset that I think would be useful for many people. Also, I’ve only implemented this class to support the creation of the cart and submission to Google, I haven’t included any functionality for greater integration. This greater integration would involve creating web services that Google could call to update the website on changes to the order status, shipping, etc. The way I’ve set this up, all of that is skipped, and store owner would receive orders via email or Google’s Checkout interface.

Limitations:

• No support for cart expiration
• No support for merchant calculations for tax/shipping/gift certificates as these require HTTPS and I don’t have it and don’t care to use it
• No support for requesting the buyers phone number because I didn’t notice that field until just now!
• No support for shipping restrictions – i.e. shipping option 1 is only available in these zip codes/states/etc
• No support for complicated tax rules. Tax can be setup on a state by state basis. One alternative tax rule ‘taxfree’ is setup to allow certain items to be tax free. No support for other alternative tax rules.
• Currently doesn’t support customization of the form and checkout image

In order to work around some of these limitations, I’ve provided a method called setDefaultXML which allows the developer to specify a default XML file to be used. The class will then fill in the items, do the encryption, and generate the form and checkout image. This allows much greater flexibility and support for all of Google’s options, when needed.

Here’s a simple example of how I might use it:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

require('GoogleCheckout.php');
 
$merchant_id = 'XXXXXXXXXXXXXXX';
$merchant_key = 'XXXXXXXXXXXXXXXXXXXXXX';
 
$google = new Gregphoto_Service_Google_Checkout($merchant_id,$merchant_key);
$google->setMode('sandbox');
$google->addItem('Doolittle','Doolitle CD by The Pixies (1989)','11.98',1);
$google->addItem('PSCREEN18','18 inch Pizza Screen','7.99',3);
$google->addItem('MYWIDGET01','New tax free widget - Student Use Only','149.21',1,'','taxfree');
$google->addItem('NDISC01','New Customer Discount','-10',1);
$google->editCartUrl = 'http://www.gregphoto.net/index.php?action=editcart&source=google';
$google->continueShoppingUrl = 'http://www.gregphoto.net';
$google->setShipping('UPS Ground',19.99);
$google->setShipping('UPS Next Day',27.99);
$google->setShipping('Instore Pickup',4.99,'pickup');
$google->setStateTax('CA',.0875);
$google->setStateTax('IL',.0525);
 
echo $google->getHTMLForm();
$google->printXML();

Now, for what’s going on:

• Line 1 includes the class
• Lines 3 and 4 setup variables for the merchant id and merchant key
• Line 6 instantiates the class, passing in the merchant id and key
• Line 7 sets the class to use the Google Checkout Sandbox – this is a testing sandbox where you can setup fake accounts to use while creating your site. Paypal offerers a much richer sandbox functionality.
• Lines 8-11 add new line items to the cart, setting there name, description, price, quantity, notes, and special tax rules
• Lines 12 and 13 setup the URLs the user should be sent to if the choose to edit the cart or continue shopping
• Lines 14-16 setup various shipping options including their prices
• Lines 17 and 18 setup taxes for the users in specific states. Google Checkout supports much richer rules around taxation, but I kept it simple on a state-by-state level.
• Line 20 outputs the HTML form and checkout image that will send the cart to Google Checkout and bring the user to the Google Checkout page
• Line 21 shows the XML cart, for debugging purposes

View this example running on my site
View the API of Gregphoto_Service_Google_Checkout
Download the class and API docs
View Google’s Develper Guide for Google Checkout

This class, which you can download along with api docs uses the Zend Framework’s Zend_Http_Client functionality to perform HTTP posts to Akismet and get the responses back. More specifically, it uses the version of Zend_Http_Client that’s currently in the incubator, not the one in the regular library.

Here’s a simple usage example:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

$api_key = 'your api key here';
$website_front_page = 'http://www.gregphoto.net';
$message = array(
	'comment_author' => 'viagra-test-123',
	'comment_author_email' => 'viagra-test-123@hotmails.com',
	'comment_author_url' => 'http://www.viagra-test-123.com/ilovespam/',
	'comment_content' => "Please buy my spam.  Mechanically separated meat tastes great!"
);
 
$akismet = new Gregphoto_Service_Akismet($api_key,$website_front_page);
if($akismet->checkIsSpam($message)) {
	echo 'it is spam!';
} else {
	echo 'it is not spam!!';
}

In addition to checking whether a message is spam (Gregphoto_Service_Akismet::checkIsSpam), the following methods are provided, covering the entirety of the Akismet API:

• Gregphoto_Service_Akismet::validateKey – checks whether or not your api key is valid
• Gregphoto_Service_Akismet::submitSpam – submits a message to Akismet telling it that it is spam (normally a message that Akismet identified as not being spam)
• Gregphoto_Service_Akismet::submitHam – tell Akismet that a message it identified as spam is not actually spam

To get an API key for yourself, follow the instructions printed on blog.phpdeveloper.org:

You’ll need to go signup over on WordPress.com and, once logged in, go to your “My Dashboard” (top left link), go to the “Users” tab at the top and right there at the top of the page you’ll see “Your WordPress.com API key is…”. Easy as pie.

Signup for a free blog, but don’t worry…you only need to sign up in order to get a key – you don’t actually have to use the wordpress.com account for anything else…

For anyone looking to build a site or application using the Zend Framework that accepts comments – this could be a good little tool that should integrate very cleanly.

Enjoy, and let me know what you think.

• Zend_Http_Client – provides a class for sending HTTP requests and getting the response. I need this in order to fetch the CSV file from Yahoo!
• Zend_Cache – currently in the ‘incubator’, this class allows me to cache the response so that the application doesn’t need to get data from Yahoo on every page request.
• Zend_Json – allows for automatic serialization of objects, arrays, and strings into JSON format, perfect for using with AJAX applications. This isn’t actually used in the library, but there’s an example of how it can be used with the result of the library.

On my way through putting this together, I came across another couple of things I haven’t had much/any experience with:

• Streams wrappers
• SPL SeekableIterator interface

The calling ‘application’

My test page for this class is as follows:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

<?
function __autoLoad($className) {
	Zend::loadClass($className);
}
require('Zend.php');
 
$stocks = new Gregphoto_Service_Yahoo_Stocks();
$stocks->addStocks(array('GOOG','YHOO','MSFT','AMD','INTC'));
$stocks->setSymbols(array('s','n','l1','c1'));
$stockResult = $stocks->getStockInfo();
?>
<html>
<head>
<title>Yahoo Stocks with Zend Framework: Example</title>
</head>
<body>
<?
foreach($stockResult as $stock) {
	echo "{$stock->s}: {$stock->c1}<br>";
}
?>
 
<p>And here is a JSON string representation of the results:</p>
 
<?=Zend_Json::encode($stockResult->getArray());?>
</body>
</html>

Key points:

• Lines 2-4 setup an autoLoad function to take care of loading the Zend Framework files whenever they’re requested
• Line 7 instantiates the Gregphoto_Service_Yahoo_Stocks class
• On line 8 we pass in an array of stocks we’d like information on
• On line 9 we send in a list of symbols, indicating what information we would like on these stocks. For a detailed list of all the information that is available, check out the following link: http://www.gummy-stuff.org/Yahoo-data.htm
• Line 10 sends the request and gets back a Gregphoto_Service_Yahoo_Stocks_ResultSet object back. This class implements SeekableIterator, allowing simple iteration over the results.
• Lines 18 – 20 loop through the results, printing two symbols out: s and c1. These are the stock symbol and the change on last day of trading
• Line 25 uses the Zend_Json class to encode the results in JSON format. This would be perfect for sending back to a page in an Ajax environment

The stocks class

I’ll focus here on a couple of the key methods of this class – most of them are fairly basic. You can download all the files to see the whole thing if you want.

The first function we’ll look at is the getStockInfo method. Here’s what it looks like:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

public function getStockInfo() {
	if(!is_object($this->cacheObj)) {
		$this->getCacheObj();
	}
	$cache = $this->cacheObj;
	$url = $this->generateYahooURL();
	$id = md5($url);
	if (!($cache->test($id))) {
		$stockArray = $this->getStockArray($url);
		$cache->save($stockArray);
	} else {
		$stockArray = $cache->get($id);
	}
	return new Gregphoto_Service_Yahoo_Stocks_ResultSet($stockArray);
}

This performs the following steps:

• Gets a cache object if it doesn’t already exist
• Calls a method to generate the URL for the stock request
• Creates an md5 hash of the url to use as the cache identifier for the request
• If too old, it calls the getStockArray method and saves its result to the cache, otherwise it loads this information from the cache
• It returns a new Gregphoto_Service_Yahoo_Stocks_ResultSet object to the user

This of course, left out the most critical part – getting the stock quote CSV data from Yahoo! and converting it into an associative array. That takes place in the getStockArray method, shown below:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

private function getStockArray($url) {
	$http = new Zend_Http_Client($url);
	$response = $http->get();
	if($response->isSuccessful()) {
		require_once(dirname(__FILE__).'/csvstream.php');
		$stockArray = array();
		$GLOBALS['Gregphoto_Yahoo_Stocks_Stream'] = $response->getBody();
		$fp = fope.n('csvstr://Gregphoto_Yahoo_Stocks_Stream', 'r+');		
		while (($row = fgetcsv($fp, 2000, ",")) !== FALSE) {
			$stockArray[] = array_combine($this->symbols,$row);
		}
		unset($GLOBALS['Gregphoto_Yahoo_Stocks_Stream']);
		return $stockArray;
	} else {
		throw new Exception("Unable to get data from Yahoo Finance");
	}
}

Note: On line 8, I couldn’t get this damn thing to save unless I got rid of ‘fopen’, so I changed it to ‘fope.n’

My webhost, Dreamhost, doesn’t support allow_url_fopen, meaning I can’t use standard file functions such as file, fopen, or file_get_contents to get the CSV file from Yahoo. Instead, here I use the Zend_Http_Client class to get stock quotes CSV from Yahoo!. PHP has a built in function, fgetcsv, for converting CSVs to arrays…unfortunately it only works on file resources, like the ones you’d get if you opened the file with fopen…a function I can’t use to open a remote file. I scratched my head for a while on this one. One solution would be to save the contents of the response as a file on the filesystem and then use fgetcsv on the file. I found an alternative after many a google search – stream_wrapper_register – a function that lets you define a class that represents data as a stream…that can be used with all functions requiring a file resource. Not only did I find the idea in the PHP manual, there was actually an example of using it for CSV data in the comments – now that’s service. So here’s the steps:

• Instantiate a new Zend_Http_Client with the URL passed in from getStockInfo
• Get the reponse object and if it was successful, continue, otherwise throw an exception
• Require the csvstream.php class which has the csvstream class and the following line: stream_wrapper_register(“csvstr”, “csvstream”); This registers the class for all urls beginning with csvstr://
• Set a global variable with the value of the CSV file, the body of the HTTP response. The csvstream class looks for the value to be converted to a stream in a global variable.
• Use the fopen function to open csvstr://Gregphoto_Yahoo_Stocks_Stream, the second part of the URL being the name of the global variable I set
• After this, we loop through the file and use the fgetcsv function to create an array, combine it with the symbols chosen to make a more user-friendly associative array.
• Lastly, we unset the hack-ish global variable we had to set and return the array

And that’s really the meat of it. The rest of it is very straightforward. The Gregphoto_Service_Yahoo_Stocks_ResultSet does nothing much more than implementing the SeekableIterator function and creating new Gregphoto_Service_Yahoo_Stocks_Result instances. The Gregphoto_Service_Yahoo_Stocks_Result class itself is very simple, using the magical __get method to allow easier access to the array values, i.e. $stock->s instead of $stock['s']. I could easily have skipped the resultset and result classes, but I decided to create them so that it would work in a similar fashion to the Zend_Service classes.

All in all, I’ve found it to be very easy to work with the Zend Framework classes, though I’m still holding off on the controller/view classes until they firm up a bit and add native support for applications in subdirectories (supposedly in the next dot release).

Hope you found this interesting…you can download the code here, but don’t expect production worthy code, much documentation, or much support!