Bookmark and Share

Saturday, February 27, 2010

Mapping an Object Interface to Relational Data


Storage of data as well as access to data in RawDev is facilitate by the data aspect or model (such as in MVC). The model is divided into three separate layers. The first layer organizes raw data into uniform entities and relations. The second layer adds security to the data by providing a mechanism to define access to data and enforcing these rules. The third layer maps entities and relationships to an object oriented interface which makes it easy to deal with nested structures and apply business logic using object oriented programming constructs.

The layers in the RawDev model (the data aspect)

Relational DataAccess ControlsObject Interface
Entities, RelationshipsUsers, Groups, RolesNested Data Structures
SQL (across data sources)Authenticated Sessionsadditional Business Logic
XML Data DefinitionRow/Column Level Access 
Caching, Copying, SynchronizingLogging 
 LDAP Integration? 
Overview of the three layers

Relational Data

Chances are that you primarily use a relational database such as MySql to store your data. RawDev provides uniform access to your favorite relational database as well as any other data source. Access to other data sources is handled by plugins. You can write a simple plugin that lists the files in the file system or hooks into an online data feed. After defining the structure of your data source in XML (think create table) you can access it and join it to any other data source using regular SQL. In addition, RawDev will provide mechanisms to cache data locally, copy entire data sets as well as synchronize data.

SELECT b.url, b.title, p.latest_post, a.ranking
FROM mysql:blog b, rss:posts p, alexa:ranking a
WHERE b.url=p.url and b.domain=a.domain
Example of a join across data sources listing 10 locally stored blog urls with their latest post and the alexa ranking on the blog domain.

Access Controls

RawDev has powerful ways to provide data access to users . RawDev provides tools to manage users, roles, organizational groups, and provide a powerful interface to grant privileges to these entities. RawDev maps and enforces these privileges in the back-end (e.g. read/write, entity, row level, and column level access). Individual users access the data using authenticated sessions. Optionally, access is reported in a central log. It is on my wishlist to provide LDAP integration (after the summer).

Object Interface

The third layer maps the relational structure to an object interface. In this layer, RawDev provides additional data access tools as well as the ability for programmers to extend this. For example: say a user profile consists of many entities such as degrees, languages etc. Using this layer you have powerful tools to save the entire profile with little effort, updating only the child records that were actually changed. Further more, additional business logic can be implemented in this layer. As simple as a uniform way to display full names or as complex as the order in which records across entities can be stored given a specific business process.

Storing a form with a nested data structure becomes a piece of cake in the RawDev Object Interface.

When do I have access to this?

Although the existing production applications such as Find a Psychologist and enjoy significant parts of the RawDev model, the open source version is estimated to have the full model functionality in the summer of 2010.

Raymond Bokenkamp.

Raymond Bokenkamp, MBA, MS is the founder of Bokenkamp Consulting. He holds a Masters degrees in Computer Science from the University of Twente in the Netherlands as well as an MBA from LeBow School of Business, Drexel University. Raymond has over ten years in developing programming frameworks in academic settings as well as private companies. This year he decided to release his framework RawDev as open source. RawDev is a balanced approach to sustainable programming in PHP. He started his first company in 1991, a screen-printing business, which is still thriving today and recently expanded from the Netherlands to Poland. He is now bringing his entrepreneurial spirit to provide web solutions that make a difference. Raymond loves to do yoga, write blog posts, compete in city chases, and hike in the Wissahickon Park in Philadelphia with his wife, Lisa, and dog, Jax.

Wednesday, February 24, 2010

One-stop-shop preg.


If you use perl regular expressions on a regular basis then you probably have come across the following lines of code extensively:


if (preg_match($expression, $subject, $matches)) {
$iCareAbout = $matches[1];

Occasionaly you also needed to replace the first matched instance. Which if you also wanted to check if matches were replaced and what the matches are is more cumbersome:


if (preg_match($expression, $subject, $matches)) {
$iCareAbout = $matches[1];
preg_replace($expression, $replace, $subject, 1);

For both of these instances the RawDev preg function looks as follows:


$iCareAbout = RUtil::preg($expression, $subject); # case 1
$iCareAbout = RUtil::preg($expression, $subject, $replace); # case 2


In addition, the RawDev preg function can match/replace all instances. Lastly, it can handle an array of strings as the subject of which only the strings that matched were returned.


static mixed function preg($regex, $subject, $replace, $all, $alwaysArray)

Returns the matches of a perl regular expression in an array (getting rid of the unnecessary first element that preg_match generates) ; the result is returned in a scalar if one variable is matched (\1) and alternatively in array. The matches can also be replaced.
$regexstringThe full regular expression (including options such as "/.../ice").
$subjectmixedThe subject is a string or an array of strings that is subject to modification (passed in by reference).
$replaceboolThe optional replacement string (accepts variables such as "1").
$allboolWhether one or all instances should be matched/replaced (default: all=false).
$alwaysArrayboolBy default when only one variable is matched, it is returned as a scalar (e.g. by default"/ (a) /" is returned as scalar, "/ (a) (b) /" as an array). Setting this to true will always return the matches as an array.
returnsmixedThe match or matches. This can be a string, an array of strings or an array of an array of strings (match all). Null when no matches.


This example works on the string: "[USA] Gold, [Netherlands] Silver, [Canada] Bronze"

It matches/replaces the first country and then all countries.

The result is:



$str = "[USA] Gold, [Netherlands] Silver, [Canada] Bronze";

$str1 = $str;
$str2 = $str;
$str3 = $str;
$str4 = $str;

# find first country
$result1 = RUtil::preg("/\[(.*?)\]/", $str1);
# find and replace first country
$result2 = RUtil::preg("/\[(.*?)\]/", $str2, "\\1");
# find all countries
$result3 = RUtil::preg("/\[(.*?)\]/", $str3, NULL, true);
# find and replace all countries
$result4 = RUtil::preg("/\[(.*?)\]/", $str4, "\\1", true);



Using RUtil::preg code will reduce the amount of code you produce. Which will, in the long run, save (a) programming hours, (b) reduce bugs and (c) increase execution performance (less code to put in memory). The subject is changed by reference. This can be annoying because you need to assign a temporary var if you don't want to change the subject. Always use preg_replace when you don't care about returning matches.


RUtil API Doc

Saturday, February 20, 2010

It's not a question whether you should unit test but how much!


Unit testing matters because it will make your code more reliable. This is especially true when code needs to be updated as time goes along. Unit testing takes discipline. It is tempting to just hack a result together and use ad-hoc testing. However, by recording these ad-hoc tests in actual unit tests you will be able to run them over and over again. It is not a question of whether you should do unit testing. Rather the question is: "What's the level of detail you are going to do unit testing?". Keep it basic, especially in the beginning. Unit tests are great for diagnostics and make your programming efforts more sustainable in the long run.

From personal experience, I can tell you how many times I have quickly build/hacked applications together. Weeks later, when I had to change something basic, this could take hours or even a day because the change I made caused other parts to fail and it was hard to diagnose. Unit testing is a skill that can help you get to the next level as a programmer as well as an organization. It will take effort and persistence but when done in the right amount you should be able to reap benefits in weeks.

RawDev has tried to make unit testing as streamlined and easy to do as possible. There are 3 aspects to unit testing in RawDev: (1) a unit test, (2) a component test (the test classes that you will write), and (3) the unit test binary that runs all, some or one unit test.

Unit Test


Code is organized in functions. These functions reside in objects or are static class functions. In addition, functions can interact with their environment.

Usually an object function or a static class function. Functions can interact with their environment.
Input A function has zero or more input parameters. In rare cases these parameters defined as references in which case they can be altered by the function.
Output A function has one output parameter which could be an array.
Exception Usually based on incorrect input or failing of a resource, an exception can be thrown, which will interrup the regular flow of the code.
Object & global state Object functions can modify the state of object variables. In addition, any function can modify class variables and other global state such as databases, files etc.

Example 1

A unit test typically tests either correct output of a function or verifies if the expected exception was raised. In addition one or more asserts can be done after the function was executed. Asserts are typically tests of the object and global state. Don't worry about how results of tests are displayed, I will get to that in the next section. RawDev uses fluid API calls for usability.

Let's look at some examples. First a real basic example of a function that calculates the sum of 2 or more inputs. Each test has a title for diagnostics but as we will see later the title will set to the test function that implements the test.



function sum() {
  $params = func_get_args();
  if (count($params) < 2) throw new RException('math_too_few_params', 'Two or more parameters please.');    
  $sum = 0;   
  foreach($params as $param) $sum += $param;    
  return $sum; 

# test 1 
$t = RUnitTest::construct('sum')->title('Two Params')->in(1, 2)->out(3)->test();
print $t->icon;

# test 2
$t = RUnitTest::construct('sum')->title('One Params')->in(1)->exception('math_too_few_params')->test();
print "$t->icon\n";


The steps of the first test are: set function, set title, set input params, set output params, test function and evaluate results.

The second function tests wheter the exception is thrown as expected.

Example 2

Let's look at a simple object test next.



class Car {

var $miles = 0;

function drive($miles) {
if ($miles <= 0) throw new RException('car_illegal_miles', 'Miles should be more than zero.'); $this->miles += $miles;


$c = new Car();
$f = array($c, 'drive');

$t = RUnitTest::construct($f)->title('Simple Drive')->in(10)->out()->test();
$t->assert(10, $c->miles);
print "$t->icon\n";


In this example the test verifies whether the output is NULL. The assert tests wheter the "object variable" mile was set to 10.

Component Test

The three components to test in RawDev are: modules (or sub-modules), classes and functions. Each of these components has a setup routine (optional), zero or more unit tests and a cleanup routine (optional). Each Component test is implemented as a test class. Creating test classes for modules and classes is often not necessary.


The example below shows all the tests for the "drive" function (see example above). Note that the unit function creates a unit test object and sets the title to the name of the function. All functions that start with test[Name] are run as unit tests. It is perfectly ok to create helper functions that do not start with "test".



# class from the previous example
class Car {

var $miles = 0;

function drive($miles) {
  if ($miles <= 0) throw new RException('car_illegal_miles', 'Miles should be more than zero.'); 
  $this->miles += $miles;


# this shows what your test harnass will look like
class TCarDrive extends RComponentUnitTest {

  var $car;
  var $f;

function setup() {
  $this->car = new Car();
  $this->f = array($this->car, 'drive');

#Drive10 will show up as the title of the unit test!
function testDrive10() {
  $t = $this->unit($this->f)->in(10)->out()->test();
  $t->assert(10, $this->car->miles);

#Negative: test for an exception
function testNegative() {
  $t = $this->unit($this->f)->in(-1)->exception('car_illegal_miles')->test();


#run the harnass, in real life this is done throug: bin/runit.php
$c = new TCarDrive('function');


Component Test location

Test classes are saved in the "tests" directory using a specific path/name structure:

[RAWDEV_HOME]/tests/Util.php : indicates a component test for module Util.
[RAWDEV_HOME]/tests/Util/Car.php : indicates a component test for class Car (part of the Util module)
[RAWDEV_HOME]/tests/Util/Car/drive.php : indicates a component test for function drive of class Car (part of the Util module)

Module and Class Components

Module and class components are not required. In addition, they can contain setup/cleanup routines for the module or class only. Modules and classes do not have dependencies because they are expected to be tested as independent modular constructs.


A function may have implicit or explicit dependencies on other functions in the class. RawDev detects implicit dependencies by reading the source of the function. Explicit dependencies are added using the @dependencies notation in the function comment header (e.g. @dependencies __construct,start). RawDev (a) automatically rearranges the order that functions are tested based on these dependencies and (b) will unit test dependent functions if a depending function is tested in isolation.

Unit Test binary

[RAWDEV_HOME]/bin/runit.php is the binary that runs all unit tests it accepts zero or one argument which is the path of the component to be tested.


run all unit tests:

run all unit tests for module Util:
[RAWDEV_HOME]/bin/runit.php Util

run all unit tests for class Car:
[RAWDEV_HOME]/bin/runit.php Util/Car

run all unit tests for function drive:
[RAWDEV_HOME]/bin/runit.php Util/Car/drive

run one unit test named drive10
[RAWDEV_HOME]/bin/runit.php Util/Car/drive/testDrive10

One last note that when a component is tested, then all it's child components are tested as well. It's parent components are not tested. However the setup and cleanup routines are called for all it's parents.

Test Output

The output of any component test (or all tests) is divided into 3 parts: tree view, overall view, and failed test messages.

php runit.php Util

        display .....
        dump ..
        formatScalar .......
        maxLength ..
        page ....
        __construct .
        _match ...
        matchObject ...
        matchScalar .....
        matchArray .......
    Stdin ..
        max .X.
        min ...
        nvl .......
        preg ................
        writeFile ..


X: Util/Util/max:Array                     : Value [9] does not match expected value [10] for item []. in Match.php (115)
   Match.php            96
   Match.php            57
   Test.php             179

As you can see all tests succeeded except for the "testArray" unit test function of function max in the Util class. Extra information is displayed (including a simple trace) why the test failed.

. : OK
X : FAIL (output does not match expected)
E : EXCEPTION (unexpected exception occured)
? : NO_EXCEPTION (expected exception did not occur)


Unit Testing takes discipline. When done at the appropriate amount it will increase productivity and reliability. It is also a great diagnostic tool.

RawDev organizes unit tests into component test classes. The runit binary can test one unit test, all unit tests or any component and it's children. When a function changes the state of the object or global state then multiple assert calls can be made to verify the changed state. For this reason the object or global variables should be accessible publicly or by method. Unit tests are most effective when functions have one specific task. Doing unit testing will actually alter the way you code (this is not a commercial for suits).


RUnitTest API Doc

RComponentUnitTest API Doc

PHP Magazine articel

Wednesday, February 17, 2010

Debug PHP code in an IDE in less than one hour.


Although RawDev offers debugging tools, it can be useful to use an IDE with a debugger. I will show you how to setup PHP debugging using open source software for both command line and web page debugging.

 This example uses eclipse as the IDE and XDebug as the PHP module, note that this is not the only software available. You need root access and already have apache and php installed. The instructions are for Mac OS X / Unix but should be very similar for Windows users.


* Setup XDebug
  * Install XDebug
  * Alter php.ini
* Install Eclipse
* Hello World example
  * Create Hello World example
  * Debug as PHP Script (command line)
  * Debug as PHP Web Page

Setup XDebug

Install XDebug (easiest)

> pecl install xdebug

Install XDebug (unix / alternate)

> cd /usr/local/src wget
> tar xvfz xdebug-2.0.5
> cd xdebug-2.0.5
> phpize
> ./configure --enable-xdebug
> make
> # mkdir /usr/local/php/modules # if it doesn't exist
> cp modules/ /usr/local/php/modules/

Alter php.ini

Add the following lines to the php.ini :

# under the extensions ...

# somewhere at the bottom ...

Test XDebug

* restart apache
* create a script (info.php) in your web_root folder.
* check the script and make sure XDebug is enabled see the screenshot at the bottom of document.

Install Eclipse

* download Eclipse for PHP Developers from:
* install it

Hello World example

Create example

* run eclipse
* >File>New>Project>PHP>PHP Project
* Use default path: "~/Documents/workspace/Hello"
* Project Name "Hello" [Next] [Finish] [Yes]
* >File>New>PHP File
* Name : index.php [Finish]

Debug as PHP Script (command line)

* >settings>PHP>PHP Executables>Add
* Name: "php" ;
   Path: "/usr/local/php/bin/php" ;
   php.ini: "/usr/local/php.ini" ;
   PHP Debugger: "XDebug"
* right click (in index.php source window)
* select debug as PHP Script

Debug as PHP Web Page

* Make sure the project path is visible in the webroot
* one way: create a symbolic link to project directory and
                   project directory is visible for all (e.g. chmod 755)
* test this in a browser
* >settings>PHP>PHP Servers>Add (&make default)
* Name: "php" ;
    Path: "/usr/local/php/bin/php" ;
    php.ini: "/usr/local/php.ini" ;
    PHP Debugger: "XDebug" [
* right click (in index.php source window)
* select debug as PHP Web Page


Obviously these are instructions just to get you started. The other debugging module is "Zend Debugger" and other PHP IDE's are available (e.g. Komodo). RawDev will use more of XDebug extended functionality such as profiling.



phpinfo screenshot:

Sunday, February 14, 2010

When var_dump is not enough.


Using this library you can browse the content of complex variables, one nested level at the time by using commands such as zoomin, zoomout and exit. Currently, this class should only be used for command line applications. Web browsable functionality will be added later using through firephp/firebug.


By executing the snippet below you will see the following screen. At this point you can decide to exit (or zoomout), or zoom in to nested variable links [1] and [2].



class Test {

var $a='hi';
var $b = array(1, 2);


$complex = array(1, 'hi', array(99, 17), 'std' => new stdClass(), new Test(), array());




For command line application development this beats var_dump and will save you a ton of time when debugging.


RDumper API Doc

Future enhancements

Color coding?

Saturday, February 13, 2010

Command line user input


RStdin is tiny class that deals with interactive keyboard input from the command line. For testing purposes the keyboard input can be faked.


This example first shows regular use. The output is trimmed by default but this can be changed (see RStdin API Doc). In the second part you can see how the keyboard input can be faked for testing purposes.



# regular use
$input = RStdin::read('Please enter input: ');
print "$input";

# testing use
RStdin::$buffer[] = 'hello'; # for testing purposes the input buffer can be set
$input = RStdin::read('Please enter input: ');
print "$input";



This class is useful when dealing with command line applications. RawDev uses this class in the Dumper utility in which you can interactively view nested complex data structures.


RStdin API Doc

Saturday, February 6, 2010

Handling errors, warnings and exceptions with one handler.


In RawDev, all PHP errors and exceptions can be handled centrally using the Error Reporting library. In addition, RawDev gives more options of error messages than the standard PHP error_reporting level. For example, by default strict errors such as illegal variable references are returned but strict errors such as undefined array offsets are not. RawDev finds that being more strict with variable (and object property) references leads to catching programming mistakes earlier in the development process. Most RawDev users will find this class extremely useful.


In the example below, I trigger several PHP errors: invalid offset, illegal variable reference and illegal object property reference. As you can see, the invalid offset is ignored by default and both other errors are thrown as RExceptions (RawDev Exceptions). Any other RExceptions can be handled by a central handler as well.




$b = array();
if ($b[0]); # this will not trigger an error

$difficultVariable = 17;
try {
if ($difficultVaariable); # this triggers an error because the wrong variable is used.
catch (RException $e) {
print $e->getMessage()."\n";

class Test {

$a = new Test();

try {
if ($a->b); # this triggers an error because an invalid object variable is used.
catch (RException $e) {
print $e->getMessage()."\n";



This is just one of these classes that as a developer you will get attached to because it forces you to code a little tighter but avoids having to debug illegal variable and object property mistakes. The central error handling is a nice bonus.


Error Reporting RawDev API Doc