If the PHP installation was not compiled in safe mode then we can change this value within the application using set_time_limit. So for any long running scripts setting the time limit to zero will tell PHP to allow the script to run forever.

However if your PHP installation is running in safe mode, this function is blocked and there is no way of altering the time limit from within the application. Therefore the only way to get the an application to complete its task the php.ini max_execution_time setting will need to be altered. In the case of WordPress Backup to Dropbox this setting needs to be set to at least 3600 seconds  (1 hour).

How easily this value can be changes depends on how your hosts PHP installation is configured. If your host allows it you can put a file named php.ini inside the root of your WordPress installation with the max_execution_time set.

max_execution_time = 0

If this does not work then you have to edit the value in your php.ini file. The location of this file depends on your operating system and a quick Google search will yield plenty of literature on how this is done.

Up until now, I have always found this to be a predicament in any programming language. You have a lovely class that follows all the rules of object oreiented programming, including encapsualtion and information hiding, that only exposes a small number of methods to the public. In many cases, to keep your code DRY, these public methods rely on private methods to perform task that is very specific to the class and is of no use in the public domain.

So, how do you individually test these private methods of your class without making them public? Well as you may have guessed… PHP’s ReflectionClass is one way of doing so!

The class below is good example, it has the public method validateData that relies on functionality of the constructor, where the incoming data is sorted, and the checkValue method, that ensures that the is a number between 5 and 10.

class Foo {

	private $data = array();

	/**
	 * Creates a new Foo object by taking an array of items
	 * and sorting it before setting the data property
	 * @param  $data
	 */
	function __construct($data) {
		sort($data);
		$this->data = $data;
	}

	/**
	 * Checks whether a value is between 5 and 10
	 * @param  $value
	 * @return bool
	 */
	private function checkValue($value) {
		if ($value && $value > 5 && $value < 10) {
			return true;
		}
		return false;
	}

	/**
	 * Validates the data of this class's data to ensure that all
	 * its values are sorted and between 5 and 10
	 * @return bool
	 */
	public function validateData() {
		$is_valid = true;
		$prev_value = 0;
		foreach ($this->data as $value) {
			if (!$this->checkValue($value) || $prev_value > $value) {
				$is_valid = false;
				break;
			}
			$prev_value = $value;
		}
		return $is_valid;
	}
}

Finally the PHPUnit class below is a comprehensive set of tests for the above class, it uses the ReflectionClass in each of our tests:

• To verify that our constructor is correctly sorting the incoming array by extracting the private class property ‘data’ and checking that it is, in fact, sorted.
• To test the private checkValue method to make sure that it conforms to our rules
• Finally, to test the validateData method with an invalid (not sorted) array to verify it correctly returns false

class DataTest extends PHPUnit_Framework_TestCase {

	/**
	 * Foo::$data is private so lets php reflection
	 * class to test it
	 * @return void
	 */
	public function testConstructor() {
		//First we need to create a ReflectionClass object
		//passing in the class name as a variable
		$reflection_class = new ReflectionClass("Foo");

		//Then we need to get the property we wish to test
		//and make it accessible
		$property = $reflection_class->getProperty('data');
		$property->setAccessible(true);

		//We need to create an empty object to pass to
		//ReflectionProperty's getValue method
		$foo = new Foo(array(7, 6, 8));

		$this->assertEquals(array(6, 7, 8), $property->getValue($foo));
	}

	/**
	 * Foo::checkValue is private so lets php reflection
	 * class to test it
	 * @return void
	 */
	public function testCheckValue()
    {
		$reflection_class = new ReflectionClass("Foo");

		//Then we need to get the method we wish to test and
		//make it accessible
		$method = $reflection_class->getMethod("checkValue");
		$method->setAccessible(true);

		//We need to create an empty object to pass to
		//ReflectionMethod invoke method followed by our
		//test parameters
		$foo = new Foo(null);

		//Boundary test - False expected
		$this->assertFalse($method->invoke($foo, 5));

		//Good data - True Expected
		$this->assertTrue($method->invoke($foo, 7));
    }

	/**
	 * validateData relies on checkValue and the constructor.
	 * So now that, from the tests above we know that these two
	 * work as expected we can test it!
	 * @return void
	 */
    public function testValidateData()
    {
		$foo = new Foo(array(6, 7, 8 ,9));
		$this->assertTrue($foo->validateData());

		$foo = new Foo(array(10));
		$this->assertFalse($foo->validateData());

		//We may also want to test to confirm our rule that
		//the array must be sorted here.

		$reflection_class = new ReflectionClass("Foo");

		//Then we need to get the property we wish to modify,
		//set it to accessible and then override its value
		//with an invalid one
		$property = $reflection_class->getProperty('data');
		$property->setAccessible(true);
		$property->setValue($foo, array(7, 9, 8));

		$this->assertFalse($foo->validateData());
    }
}

Now because each individual method is tested you can easily pinpoint any errors that may be introduced as the code evolves. Obviously this is overkill for a simple class like this, however, you may have more complicated private methods that provide some crucial functionality to a public method that should be individially tested.

First I created this neat little class that can be used to create an object model of MenuItems that can be later serialized into a HTML unordered list. This model is basically a linked list of MenuItems where the serialize function just iterates through each object and its children converting its properties into a string.

class MenuItem {

    private $name;
    private $url;
    private $level;
    private $items;

    public function __construct($item_name, $item_lvl, $item_url = "#") {
        $this->name = $item_name;
        $this->url = $item_url;
        $this->level = $item_lvl;
        $this->items = array();
    }

    public function add_item(MenuItem $menu_item) {
        $this->items[] = $menu_item;
    }

    public function serialize() {
	$html = "";

        if ($this->level == 0) {
            $html = "<ul class=\"menu\">\n";
        }

        if (!empty($this->items)) {
            $html .= "<li class=\"{$this->get_class()} menu_arrow\">";
        } else {
            $html .= "<li class=\"{$this->get_class()}\">";
        }

        $html .= "<a href=\"$this->url\">$this->name";

        if (!empty($this->items)) {
            $html .= "</a>\n<ul class=\"{$this->get_class()}_block\">\n";
            foreach ($this->items as $menu_item) {
                $html .= $menu_item->serialize();
            }
            $html .= "</ul>\n";
        } else {
            $html .= "</a>";
        }

        $html .= "</li>\n";

        if ($this->level == 0) {
            $html .= "</ul>\n";
        }

        return $html;
    }

    private function get_class() {
        switch ($this->level) {
            case 0:
                $class = "level_zero";
                break;
            case 1:
                $class = "level_one";
                break;
            case 2:
                $class = "level_two";
                break;
        }
        return $class;
    }
}

This class makes it very easy to dynamically generate a multi tiered menu. All you have to do is create your base items and add them to the MenuItem that they belong too.

$search_links = new MenuItem("Search", 1);
$search_links->add_item(
        new MenuItem("Google", 2, "http://www.google.com")
);
$search_links->add_item(
        new MenuItem("Yahoo", 2, "http://www.yahoo.com")
);

$social_links = new MenuItem("Social", 1);
$social_links->add_item(
        new MenuItem("Facebook", 2, "http://www.facebook.com")
);
$social_links->add_item(
        new MenuItem("Twitter", 2, "http://www.twitter.com")
);

$menu = new MenuItem("Links", 0);
$menu->add_item($search_links);
$menu->add_item($social_links);

echo $menu->serialize();

The code above generates the unordered list below which, as mentioned before, can be controlled with pure CSS in the newer standards compliant browsers.

<ul class="menu">
<li class="level_zero menu_arrow"><a href="#">Links</a>
<ul class="level_zero_block">
<li class="level_one menu_arrow"><a href="#">Search</a>
<ul class="level_one_block">
<li class="level_two"><a href="http://www.google.com">Google</a></li>
<li class="level_two"><a href="http://www.yahoo.com">Yahoo</a></li>
</ul>
</li>
<li class="level_one menu_arrow"><a href="#">Social</a>
<ul class="level_one_block">
<li class="level_two"><a href="http://www.facebook.com">Facebook</a></li>
<li class="level_two"><a href="http://www.twitter.com">Twitter</a></li>
</ul>
</li>
</ul>
</li>
</ul>

The list above is controlled with the tiniest amount of CSS below. Of course the nicer you wan’t your menu to look the more CSS you will need to throw in!

ul.menu li ul {
	display: none;
}

The JQuery code I used to control the above menu is larger then it needs to be in order to make the menu support most browsers and operating systems. Many of the hacks in the script is to force Internet Explorer 6/7 to conform to the likes of Chrome and Firefox. Only the min width value needs to be set here to get your menu pop outs positioned correctly.

/* IE does not support min-width so we can get it with js since we are
 * already iterating through the items to display them.
 */
function setMinWidth(element) {
	if (element.width() < 150) {
		element.css('width', '150px')
	}
}

/* IE positoning is kinda random compared to FF, Chrome and Safari so
 * this is to force it to conform.
 */
function positionPopout(element, top) {
	element.css('display', 'block');
	element.css('top', top + "px");
	setMinWidth(element);
}

$(document).ready(function() {
	$('li.level_zero').hover(
		function() {
			var element = $('ul.level_zero_block', this);
			var top = $(this).offset().top + $(this).height();

			//Fix IE left
			element.css('left', ($(this).position().left + 2) + "px");
			positionPopout(element, top);
		},
		function() {
			$('ul.level_zero_block', this).css('display', 'none');
		}
	);

	$('li.level_one').hover(
		function() {
			var element = $('ul.level_one_block', this);
			var top = $(this).offset().top -  + $(this).height();

			positionPopout(element, top);
			setMinWidth(element);
		},
		function() {
			$('ul.level_one_block', this).css('display', 'none');
		}
	);

	$('li.level_two').hover(
		function() {
			var element = $('ul.level_two_block', this);
			var top = $(this).offset().top - ($(this).height() * 2);

			positionPopout(element, top);
			setMinWidth(element);
		},
		function() {
			$('ul.level_two_block', this).css('display', 'none');
		}
	);
});

This way of providing a drop down menu for your website is not a new idea, however I think using the MenuItem class is an elegant and easy way of dynamically generating this style of menu.

I am very impressed in how easy it was to write in PHP! Instead of using class and method attributes like I did in the C# solution, I wrote a base class to store this functionality. Therefore any class that I want to collapse into a string or be built into a model should inherit this class.

What I really like about PHP over C# is the ability to dynamically build function calls and even object declaration. You can see below that get_input_string and get_array use these language features respectively. This makes it really easy to write code that deals with anonymous classes and objects.

Here is my Template class which provides similar functionality to my static method extensions I wrote in C# here.

class Template {
    private $InputTemplate;
    private $OutputCounterLen;
    private $ArgArray = array();

    public function __construct($argArray, $input_Template, $output_counter_len) {
        $this->InputTemplate = $input_Template;
        $this->ArgArray = $argArray;
        $this->OutputCounterLen = $output_counter_len;
    }

    public function get_input_string() {
        $template = $this->InputTemplate;
        foreach ($this->ArgArray as $key => $argument) {
            $func = "get_$key";
            $val = $this->$func();
            if (strlen($val) > $argument['len']) {
                throw new Exception("Too Long!");
            }
            if (!preg_match($argument['regex'], $val)) {
                throw new Exception("Regex missmatch!");
            }
            $template = str_replace("{".$key."}", $val, $template);
        }
        return $template;
    }

    public function get_array($str) {
        $count = substr($str, 0, $this->OutputCounterLen);
        $str = substr_replace($str, "", 0, $this->OutputCounterLen);
        $arr = array();
        for ($i = 0; $i < $count; $i++) {
                $class = get_class($this);
                $obj = new $class();
                foreach ($this->ArgArray as $key => $value) {
                    $val = substr($str, 0, $this->ArgArray[$key]['len']);
                    $func = "set_$key";
                    $obj->$func(trim($val));
                    $str = substr_replace($str, "", 0, $this->ArgArray[$key]['len']);
            }
            $arr[] = $obj;
        }
        return $arr;
    }
}

Now I have a Template base class that can build a string using the objects variables based on its assigned template. Below is a class the inherits the above template and and declares the maximum length and regular expression constraints of each of the classes properties. I think this part is done more elegantly in my C# solution here because you can clearly see what constraints apply to the property because they are grouped together. As far as I know PHP does not have this functionality so I had to declare these constraints in an array in the constructor of the class.

Note: Each property must have a getter and a setter to work with the Template functions. I do miss the “{ get; set; }” of C# here.

class Foo extends Template {
    private $Bar;
    private $Baz;

    public function __construct($bar = "", $baz = "") {
        $this->Bar = $bar;
        $this->Baz = $baz;

        $argArray['bar'] = array('regex' => "/^[a-zA-Z\s]+$/", 'len' => 10);
        $argArray['baz'] = array('regex' => "/^[a-zA-Z\s]+$/", 'len' => 10);
        parent::__construct($argArray, "{bar} {baz}", 2);
    }

    public function get_bar() {
        return $this->Bar;
    }

    public function get_baz() {
        return $this->Baz;
    }

    public function set_bar($val) {
        return $this->Bar = $val;
    }

    public function set_baz($val) {
        return $this->Baz = $val;
    }
}

Finally to get your string based on the properties of Foo all you need to do is call get_input_string. The echo will print “Hello World” which is based on the template string “{bar} {baz}” declared in class Foo’s constructor.

$fooObj = new Foo("Hello", "World")
echo $fooObj->get_input_string(); //Will print "Hello World"

Also, to get an array of Foo objects from a string passed to to the get_array_method you can use the following. Sadly, this means you need to create a redundant Foo object in order to call get_array. Using PHP 5.3 I could make a static method and use the new late static binding function to get the class name, however I would also need a way of statically declaring the ArgArray containing the property constraints. So this will do for now.

$arr = $fooObj->get_array("3 One 1     One 2     Two 1     Two 2     Three 1    Three 2    ");

echo $arr[0]->get_bar(); //Will print "One 1"
echo $arr[0]->get_baz(); //Will print "One 2"

echo $arr[1]->get_bar(); //Will print "Two 1"
echo $arr[1]->get_baz(); //Will print "Two 2"

echo $arr[2]->get_bar(); //Will print "Three 1"
echo $arr[2]->get_baz(); //Will print "Three 2"

As you can see the above PHP solution is written in significantly less lines of code then its C# counterpart. There are some parts of the C# solution a prefer over the PHP solution, namely the class and method attributes. However I have to say overall I prefer my PHP solution. To be idiomatic I had to change the PHP solution quite a bit. I reckon I could take the same approach in C# and it will yield less code then the original however I still thing the PHP solution will surpass!

Oh and this post is in no way saying that PHP is better then C# all the time! I just think in this particular case it was easier and, in my opinion, a better solution in PHP.