Zend Framework’s project lead, Matthew Weier O’Phinney, has a lot of great thoughts about Modeling that I’ve been trying to stick to. In implementing those ideas, I’ve started thinking out some base classes to build my Models on top of. Obviously these classes won’t work for everyone. But they should work for a lot of “typical” web applications.

That said, here are some notes that I’ve been putting together. I’m posting them now (very early) in hopes that I get some feedback.

The 6 Classes

Galahad_Model

This is the base class that all my others extend. It is there mostly to provide some helper functionality that all my other classes use (mostly for guessing class names based on a naming convention—more on that later).

Galahad_Model_Entity

The Entity is the base for all things. For example, a User would extend the Entity class. The Galahad_Model_Entity class has some basic methods for getting other objects. I haven’t thought this entirely through yet, but an example would be the Entity’s “Parent” Service (see below) or maybe a Form associated with that model or something similar.

Galahad_Model_Collection

The Collection class is just a wrapper for an array of Entities. I like this because it allows for type hinting/etc. This is pretty much a generic wrapper for an array that implements Iterator and Countable. I can’t think of much more that it needs.

Galahad_Model_Service

This probably doesn’t belong as part of the “Model”—I need to think that out. The Service Layer is where your application logic happens that’s not strictly part of a particular Model (for example, an interaction between two Models). An example might be authentication. The service layer will often map pretty closely to a public API (although obviously there will be things that your application can do that shouldn’t be exposed to the public).

Galahad_Model_DataMapper

The DataMapper maps your Entity to the appropriate DAO (see below) and makes sure the DAO gets the data it’s expecting. The way I think about this is that the Data Mapper expects an Entity as its input, but passes an array to the DAO.

Galahad_Model_Dao

The Data Access Object (DAO) is what takes the actual data in your entity and persists it. The most common DAO is going to be a database, but a web service could be a DAO as could a filesystem or any other method of persisting data. The DAO is going to have similar methods as the DataMapper, but it expects just the data—nothing else (that’s why you need the DataMapper to fetch and process the data in your Entity). An easy way to show this is in code:

class Default_Model_DataMapper_User
  extends Galahad_Model_DataMapper
{
    public function save(User $user)
    {
        $dao = $this->_getDao();
        $dao->save(array(
            'name' => $user->getName(),
            'email' => $user->getEmail(),
            'date_modified' => time(),
        ));
    }
}
class Default_Model_Dao_DbTable_User
  extends Zend_Db_Table_Abstract
  implements Galahad_Model_Dao_Interface
{
    protected $_name = 'user';

    public function save(Array $data)
    {
        $this->insert($data);
    }
}

Notes

I’m going to reiterate one more time that this is a very early concept and that I’m looking for feedback. It could be that I’m thinking about things completely backwards and it all needs to be thrown away. At this point I certainly don’t recommend people running too far with these ideas until they’ve been discussed/thought out a little more.

About the Galahad_Model base class—since all the different pieces of your model will likely follow the same naming conventions, the Galahad_Model class provides some helper functionality to guess the name of classes. For example, inside of Default_Model_DataMapper_User you’ll probably need to get an instance of Default_Model_Dao_DbTable_User. So Galahad_Model_DataMapper provides a nice getDao() method to do this for you. If you’ve set the DAO, it uses that, but if you didn’t, it assumes you want a DbTable, guesses the name for you based on the DataMapper’s class name (so that if you choose My_Model_DataMapper_Person it’ll know to return a My_Model_Dao_DbTable_Person) and instantiates it for you.

Thoughts?

What do you think? Does this make any sense? Or am I trying to make a simple thing more complicated than it needs to be? I think a lot of this would make more sense in code, so maybe I’ll try to get what I have started cleaned up a little and attach it to this post. In the meantime, I’d love feedback (in the comments below, or to @inxilpro.

/**
 * Simple Obfuscation Class
 *
 * The beginning of an obfuscation class, made primarily to obfuscate
 * email addresses within a block of text or HTML.  Used in conjunction
 * with reCAPTCHA's Mailhide service  or
 * a database-driven e-mail address hider.
 *
 * LICENSE
 *
 * 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 3 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 .
 *
 * @author     Chris Morrell
 * @copyright  Copyright 2008 Chris Morrell
 * @version    0.1
 * @license    GPL
 *
 */
class Galahad_Obfuscator
{
	const EMAIL_ANCHOR = 101;
	const EMAIL_URL = 102;
	const EMAIL_DISPLAY = 103;

	protected $mailtoRegexp = '/((.*?)<\/a>/is';
	protected $emailRegexp = '/\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b/i';

	/**
	 * Public method to obfuscate all e-mail addresses in a string
	 *
	 * @param string $string
	 * @return string
	 */
	public function emailAddresses($string)
	{
		$string = $this->replaceMailto($string);
		$string = $this->replaceEmail($string);
		return $string;
	}

	/**
	 * Private function to replace all e-mail addresses with
	 * obfuscated string (most often links)
	 *
	 * @param string $string
	 * @return string
	 */
	private function replaceEmail($string)
	{
		$string = preg_replace_callback($this->emailRegexp, array($this, 'processEmail'), $string);
		return $string;
	}

	/**
	 * Private function to handle all found e-mail addresses in string
	 *
	 * @param array $matches
	 * @return string
	 */
	private function processEmail($matches)
	{
		return $this->obfuscateEmail($matches[0], self::EMAIL_ANCHOR);
	}

	/**
	 * Private function to replace all mailto: anchors with
	 * obfuscated anchors
	 *
	 * @param string $string
	 * @return string
	 */
	private function replaceMailto($string)
	{
		$string = preg_replace_callback($this->mailtoRegexp, array($this, 'processMailto'), $string);
		return $string;
	}

	/**
	 * Private function to handle all found mailto: anchors
	 *
	 * @param array $matches
	 * @return string
	 */
	private function processMailto($matches)
	{
		$newUrl = $this->obfuscateEmail($matches[2], self::EMAIL_URL);
		$inner = $matches[4];

		if (preg_match($this->emailRegexp, $inner)) {
			$inner = $this->obfuscateEmail($inner, self::EMAIL_DISPLAY);
		}

		return "{$matches[1]}{$newUrl}{$matches[3]}>{$inner}";
	}

	/**
	 * Subclass this method to obfuscate the address however you see
	 * fit (whether with Mailhide or some other system).  Right now
	 * this function isn't very helpful, as it obfuscates all e-mail
	 * addresses and links them to #
	 *
	 * @param string $email
	 * @param int $type
	 * @return string
	 */
	protected function obfuscateEmail($email, $type = self::EMAIL_ANCHOR)
	{
		$email = substr($email, 0, strpos($email, '@') + 1) . '...';

		if ($type == self::EMAIL_ANCHOR) {
			return "<a href="\">{$email}</a>";
		} else if ($type == self::EMAIL_URL) {
			return "#";
		}

		return $email;
	}
}

Here’s some sample usage:

class My_Obfuscator extends Galahad_Obfuscator
{
	protected function obfuscateEmail($email, $type = self::EMAIL_ANCHOR)
	{
		$id = $this->emailToId($email);
		$email = substr($email, 0, strpos($email, '@') + 1) . '...';

		if ($type == self::EMAIL_ANCHOR) {
			return "<a href="\">{$email}</a>";
		} else if ($type == self::EMAIL_URL) {
			return "http://yoursite.com/get-email.php?id={$id}";
		}

		return $email;
	}

	private function emailToId($email)
	{
		// Implement this by adding the email to a database
		// and returning the row's ID, for example
		return rand(1,500);
	}
}

$html = 'some string with e-mail addresses in it.';
$obfuscator = new My_Obfuscator();
echo $obfuscator->emailAddresses($html);

So far the class has worked well with limited testing. Obviously it handles both e-mail addresses in plain text and mailto: links. Please let me know if you find any bugs in it, or have a suggestion about how to make it better.

We submitted the files to IndyHall Labs if anyone is interested in using them.  If I have time I’ll be adding some new functionality (Saul added a wishlist in the README file, and I’d definitely love to tackle some of those issues).

You can download the files from GitHub: https://github.com/IndyHallLabs/css-sprite-generator/