As you know, I have experienced with several PHP frameworks before, but all of them have many things in common: MVC, Controller-Action mapped to route, etc. When I read about micro-frameworks, they don’t enforce you to any fixed architecture. You could build your own architecture, they only provide the basics such as routing and database wrapper, thus the name “micro”.

But just like PHP frameworks, there are many PHP micro-frameworks. One of the oldest is Limonade, too bad it’s not actively developed anymore, i think. The other name I stumbled upon is Slim Framework, one of Sinatra-inspired framework, quite good. Then I found Fat-Free Framework, which some article said “tiny script with real muscle” or what I may say “kecil kecil cabe rawit” in Indonesian.

A bit about Fat-Free, I like how it provides people with many “getting started” guides so new people could understand how to use it. Also, it has many features despite having such small size. I happened to read all those guides and done some “hello world” using Fat-Free. But what I dislike is how it uses PHP eval() function. I checked there are about 10 occurrences of eval(). But I’m going to keep Fat-Free as my backup choice for my project.

Next, I saw Laravel, a new PHP micro-framework with “Clean & Classy” slogan. At first I notice how it also provides good getting started guide like Fat-Free. Even tough it has less feature, it didn’t use any eval(), so a big plus in my opinion. When I skim through Laravel source code, I realize how beautiful it is written. Laravel uses latest PHP technology like anonymous function and namespace very well. For example, let’s see a portion of Eloquent (Laravel’s ORM) class:

<?php namespace System\DB\Eloquent;
	use System\DB;
	use System\Str;
	use System\Config;
	use System\Inflector;
	use System\Paginator;

	abstract class Model {
	...

When I saw this, I was like “This is the one!”.

The only downside of Laravel is that the fact it’s still new (started about June 2011) so it still need many improvements, especially its ORM. But I saw a bright future and I think I’m gonna use Laravel for my project.

Next? I’m gonna write a simple blog tutorial using Laravel.

Anyway, now I think I have something to write about so I’ll start with writing a post about I’m coming back to this blog. And this is that post.

Next? I’m thinking about micro-framework.

For example:

usual_code();

sometimes_unused();
sometimes_unused_too();

another_code();

If we want to comment some lines:

usual_code();
/*
sometimes_unused();
sometimes_unused_too();
*/
another_code();

We modified two spots. Now, I prefer to do just one modification each “toggle” (comment-uncomment switch), so I use this:

usual_code();
/* Some description
*/
sometimes_unused();
sometimes_unused_too();
/**/
another_code();

To comment them:

usual_code();
/* Some description
     <-- only need to delete this part, one spot
sometimes_unused();
sometimes_unused_too();
/**/
another_code();

More efficient. IMHO.

$string = 'an apple above the head';

function break_string() {
  global $string;
  return 'break ' . $string;
}

This practice has some disadvantages, one of them is we can’t directly know the origin of the global variables. Let’s say we have this code:

include 'common_function.php';
include 'pedicure_function.php';
include 'medicure_function.php';

function break_string() {
  global $string;
  return 'break ' . $string;
}

Can you know where is the origin of global $string? We need to look through each of those included files and search for variable $string which resides in global scope. This might take some times, so I propose a better way to utilize global variables.

Let’s create one class as a container to all global variables by using static properties. To illustrate, see this piece of code:

// Global container
class G {
  public static $string;
}

G::$string = 'an apple above the head';

function break_string() {
  return 'break ' . G::$string;
}

Not only that we don’t need to write “global” in every functions, we could also find the origin of global $string easier, because it has G:: prefix. Finding the definition of a class is so much easier than finding a variable because people usually write one class per one file. Let’s take a look at this piece of code:

include 'class/G.php';
include 'common_function.php';
include 'header.inc';

function break_string() {
  return 'break ' . G::$string;
}

In a glance, we could guess that G::$string originated from ‘class/G.php’ because we know for sure that G:: means static properties of class G and usually class G (or Whatever) will be written in file G.php (or Whatever.php).

Let’s look at the code:

<?php
/**
 * Helps you generate XML text
 *
 * $x->div(array('id' => 'isi'), $x->span('asdf'),
 *   $x->div(
 *	   $x->span('george'),
 *	   $x->img(array('src' => 'asdf.jpg'))
 *   )
 * );
 * // Will result <div id="isi"><span>asdf</span><div><span>george</span><img src="asdf.jpg" /></div></div>
 */
class X {
	public function __call($name, $params) {
		$prex = '';
		if (is_array(current($params))) { // To specify tag attributes, assign those as array in first argument
			$args = array_shift($params);
			foreach ($args as $k => $v) {
				$prex .= ' ' . $k . '="' . str_replace('"', '&quot;', $v) . '"';
			}
		}
		if (empty($params)) { // Empty tags will be shown as <tag />
			return "<$name$prex />";
		}
		return "<$name$prex>" . implode('',$params) . "</$name>";
	}

	// If PHP >= 5.3.0
	/*
	public function __callStatic($name, $params) {
		$prex = '';
		if (is_array(current($params))) { // To specify tag attributes, assign those as array in first argument
			$args = array_shift($params);
			foreach ($args as $k => $v) {
				$prex .= ' ' . $k . '="' . str_replace('"', '&quot;', $v) . '"';
			}
		}
		if (empty($params)) { // Empty tags will be shown as <tag />
			return "<$name$prex />";
		}
		return "<$name$prex>" . implode('',$params) . "</$name>";
	}
	*/
}

/* Example: */
$x = new X;
echo
$x->div(array('id' => 'isi'),
	$x->span('asdf'),
	$x->div(
		$x->span('george'),
		$x->img(array('src' => 'asdf.jpg'))
	)
);

/* If PHP >= 5.3.0
X::div(array('id' => 'isi'),
	X::span('asdf'),
	X::div(
		X::span('george'),
		X::img(array('src' => 'asdf.jpg'))
	)
);
*/

Got any question? Just ask in the comments section below.

Put this HTML code.

<pre>
	<div id="full"></div>
	H: <span id="hour"></span>
	M: <span id="minute"></span>
	S: <span id="second"></span>
</pre>

And this JavaScript code in one page.

h = document.getElementById("hour");
m = document.getElementById("minute");
s = document.getElementById("second");
f = document.getElementById("full");

function str_pad(s, n, p) {
	if (p == undefined) p = '0';
	while (s.length < n) {
		s = p + s;
	}
	return s;
}

function int_to_bin(i) {
	var b = '';
	i = parseInt(i);
	while (i > 0) {
		b = (i % 2) + b;
		i = parseInt(i / 2);
	}
	return b;
}

setInterval(function() {
	var d = new Date;
	h.innerHTML = str_pad(int_to_bin(d.getHours()), 6);
	m.innerHTML = str_pad(int_to_bin(d.getMinutes()), 6);
	s.innerHTML = str_pad(int_to_bin(d.getSeconds()), 6);
	f.innerHTML = d.getHours() + ":" + d.getMinutes() + ":" + d.getSeconds();
}, 1000);

And you will see something like this.

Here is the code he use:

javascript:h=document.getElementsByTagName('html')[0].innerHTML;function%20disp(h){h=h.replace(/</g,'\n&lt;');h=h.replace(/>/g,'&gt;');document.getElementsByTagName('body')[0].innerHTML='<pre>&lt;html&gt;'+h.replace(/(\n|\r)+/g,'\n')+'&lt;/html&gt;</pre>';}void(disp(h));

At a quick glance, this script will replace all “<” with “&lt;” and all “>” with “&gt;” inside the “<html>” tag thus removing all tags and make those tags readable.

Let’s break down the code:

1. Retrieve a copy of the page HTML

   h=document.getElementsByTagName('html')[0].innerHTML;

2. Define a function to make all tags readable

   function%20disp(h){h=h.replace(/</g,'\n<');h=h.replace(/>/g,'>');document.getElementsByTagName('body')[0].innerHTML='<pre><html>'+h.replace(/(\n|\r)+/g,'\n')+'</html></pre>';}

   function disp(h) {
   	h = h.replace(/</g,'\n&lt;');
   	h = h.replace(/>/g,'&gt;');
   	document.getElementsByTagName('body')[0].innerHTML=
   		'<pre>&lt;html&gt;' +
   		h.replace(/(\n|\r)+/g,'\n') +
   		'&lt;/html&gt;</pre>';
   }

   This is the main key of the script. First it will replace all “<” character
   into “&lt;” and all “>” into “&gt;”. After that, it will replace the content
   of “<body>” into this replaced text.

3. Run that function

   void(disp(h));

Wanna see it in action? Open any page and type this code in the address bar. Voila.

So what do we need? A storage for all URLs and their keys. Since this is just a simple URL shortener (input: 1 URL, output: 1 short URL), I use just one table:

CREATE TABLE IF NOT EXISTS `data` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT,
  `key` varchar(100) NOT NULL,
  `url` text NOT NULL,
  `visit` int(10) unsigned NOT NULL DEFAULT '0',
  PRIMARY KEY (`id`),
  UNIQUE KEY `key` (`key`)
) ENGINE=MyISAM  DEFAULT CHARSET=latin1;

‘id’ column is the primary key, ‘key’ column is the unique identifier of URL much like “dGouHS” in http://bit.ly/dGouHS, ‘url’ column is the originial URL, and ‘visit’ column simply stores how many times the short URL visited.

How does the app works? To keep it simple, I break down the app into many functions so that the “main program” is readable, like this:

// The "main program", the code literally explains itself
startup();
if (is_requesting_url()) {
	if (is_key_exist()) {
		redirect_to_url();
	} else {
		display_page_with_error();
	}
} else if (is_submitting_url()) {
	if (is_url_valid()) {
		display_page_with_result();
	} else {
		display_page_with_error();
	}
} else {
	display_page();
}
shutdown();

Since all of the functions use no arguments, how could they communicate? Global variables? Since I don’t really like writing “global $something” in every function, I use a class which only consists of public static variables as “global variables”:

// Global "variables" connecting all functions
class G {
	public static $full   = 'http://localhost/short.php/'; // CHANGEME
	public static $base   = '/short.php/'; // CHANGEME
	public static $conn   = null; // Database connection
	public static $row    = null; // Last row retrieved
	public static $key    = null; // Key being requested or generated
	public static $url    = null; // URL being submitted or retrieved
	public static $error  = null; // Error message
	public static $result = null; // Result message
}

This way I need only type “echo G::$full” instead of “global $full; echo $full”. Instead of putting the entire source code here, I will only explain the concept behind what each function does and you can grab the entire source code at the end of this post (yeah, skip all the way down if you want).

There are 3 actions possible in this app:

1. Visitor requests a URL to a key
2. Visitor submits a URL to be shortened
3. Visitor sees the homepage

And here’s the explanation for each function:

void startup()

System initialization, simply connecting to database

void shutdown()

Terminate the database connection

bool is_requesting_url()

Check whether this is the first action.
If $_SERVER['REQUEST_URI'] contains a key then yes it is.
Assign value to G::$key.

bool is_submitting_url()

Check whether this is the second action.
If $_POST['url'] is defined then yes it is.
Assign value to G::$url.

bool is_key_exists()

Is the requested key exists in the database?
Try to fetch SELECT * WHERE key=G::$key.
Assign value to G::$row and G::$url.

void redirect_to_url()

Send a redirection header.
Don’t forget to increase the ‘visit’ value of G::$row.

bool is_url_valid()

Check whether G::$url is a valid URL.
You could define “valid” here.
Also, insert a new entry if it is valid.
‘key’ column value is generated with base_convert($id, 10, 37).

void display_page()

Simply display the HTML of this app.
The HTML consist mainly of one form to submit new URL.

void display_page_with_result()

Generate a result message and then display the HTML.

void display_page_with_error()

Generate an error message and then display the HTML.

You know what? I realize that this kind of concept (many functions, communicating through a set of global variables) reminds me of Class and Object in OO. So, I write a variant of this app in OO style, teaser:

class Short {
	private $full   = 'http://localhost/my_lib/short.class.php/'; // CHANGEME
	private $base   = '/my_lib/short.class.php/'; // CHANGEME
	private $conn   = null; // Database connection
	private $row    = null; // Last row retrieved
	private $key    = null; // Key being requested or generated
	private $url    = null; // URL being submitted or retrieved
	private $error  = null; // Error message
	private $result = null; // Result message

	// The main program is broken down to these functions

	public function startup() {

All “G::$” replaced with “$this->” and all function calls get prefixed with “$this->”.
Finally, the complete source. And a live demo.

1. The plain old const
   from http://stackoverflow.com/questions/254514/php-and-enums/254543#254543

   class DaysOfWeek
   {
   	const Sunday = 0;
   	const Monday = 1;
   	// etc.
   }
   var $today = DaysOfWeek::Sunday;
   

2. Using method as Enum
   from http://blog.agilephp.com/2008/05/11/i-want-enums-in-php/

   class MyProject_Authorization_RBAC_Role...
   	public function REGULAR { return self::REGULAR }
   	public function WEBMASTER { return self::WEBMASTER }
   	public function ADMINISTRATOR { return self::ADMINISTRATOR }
   

3. Create a function to do the Enum
   from http://stackoverflow.com/questions/3836385/does-php-have-structs-or-enums/3849974#3849974

       # enum
       # Params:
       # $array MUST be of type "array" and MUST be passed
       # $asBitwise MUST be of type "boolean" and OPTIONAL passage
       #
       function enum($array, $asBitwise = FALSE) {
   
           if($array === null)             return FALSE;   # Error incorrect type
           if(!is_array($array))           return FALSE;   # Error incorrect type
   
           $count = 0; # Counter variable
   
           # The foreach: & endforeach is just a style of programming
           # You can use brackets {} all the same
           # The case is the same for the if statements
           # I just find the colons to look a bit cleaner and so it does not
           # get confused with my javascript
   
           foreach($array as $i):
               if($i === null):
                   if($count == 0)      define($i, 0);
                   else                define($i, ($asBitwise === true) ? 1 << ($count - 1) : $count);
               endif;
               $count++;
           endforeach;
       }
   

4. Using inheritance as Enum
   from http://www.jeremyjohnstone.com/blog/2008-10-05-enums-in-php.html

   abstract class DNSRecordType extends Enum {}
   
   class A extends DNSRecordType {}
   class CNAME extends DNSRecordType {}
   class MX extends DNSRecordType {}
   
   function printDnsRecord(DNSRecordType $type, ...) {
   	   // We can now be sure $type is a DNSRecordType
   }
   

5. Using Interface as Enum
   from http://forums.devarticles.com/showpost.php?p=267640&postcount=7

   Interface IEnum
   {
   	function __constructor($_value = "")
   
   	public function Value( )
   	public function Set($_value)
   }
   
   Class Shape implements IEnum
   {
   	private $m_value;
   
   	function __constructor($_value = "")
   	{
   		if ($_value != "")
   		{
   			$this->Set($_value);
   		}
   	}    
   
   	public function Value()
   	{
   		return $this->m_value;
   	}
   
   	public function Set($_value)
   	{
   		switch($_value)
   		{
   			case "Square":
   			case "Circle":
   			case "Triangle":
   			case "Rectangle":
   			$this->m_value = $_value;
   			break;
   			default:
   			throw new Exception("Enumeration Error, Set value (" . $_value . ") is not an option for this Enumeration");
   		}
   	}
   }
   

6. Even implement an Enum class
   from http://www.phpclasses.org/package/4169-PHP-Implement-enumerated-types-using-arrays.html

   class SimpleEnum{
   
   	var $aList;
   
   	function SimpleEnum($aItems){
   		if(is_array($aItems)){
   			$this->aList = array_flip($aItems);
   		}else{
   			die('Only allow array to construct SimpleEnum.');
   		}
   	}
   
   	//Return the value of specific enum
   	function is($item){
   		if(array_key_exists($item, $this->aList)){
   			return $this->aList[$item];
   		}else{
   			/*
   				Using 'die' because I would like to have programmer's attention
   				on referring a wrong item.
   			*/
   			die('No such item in SimpleEnum: '.$item);
   		}
   	}
   
   	//Return the total length of enum
   	function length(){
   		return count($this->aList);
   	}
   
   	//Return all the enum array values
   	function values(){
   		return $this->aList;
   	}
   
   	//Print all enum array values
   	function printValues(){
   		print '<pre>';print_r($this->aList); print '</pre>';
   	}
   
   }

But, why don’t we think about this. PHP has been around for more than 10 years and it has been without Enum since the beginning. Why do you think the PHP developers doesn’t implement Enum natively until now? Perhaps because PHP doesn’t need Enum at all. If PHP doesn’t need Enum, what would we use instead? Several forums and I myself suggest we use associative array instead. Or use the class const like the first technique. Of course there are some limitations to using associative array as Enum compared to native Enum (for example in C). In a traditional Enum, we could do these.

1. Define a custom data type consists of limited possible values and keys to each values
   Yeah, in PHP you can’t define a custom data type, PHP is loosely typed anyway. But you can think of the associative array as the Enum, its keys as Enum keys and its values as Enum values.
2. Provide an abstraction so programmers only need to think about what the value MEANS rather than the exact VALUE of the value
   This is the real benefit of using Enum. Because it’s easier to remember “green” rather than “0x00FF00″ or “pi” rather than “3.1415926″. In C, usually Enum has string names which refer to integer value. So we associate the MEANING with a STRING and represent the VALUE as INTEGER. Well, we already associate STRING to ANY TYPE of value by using associative array right?

Is there any downside? Of course, one of it is because we store an associative array in a variable, anybody could change the content (aha!). If only constant in PHP could receive an array, we could do something like this:

class Enum {
	const Day = array('Sunday' => 1, 'Monday' => 2, 'Tuesday' => 3, 'Wednesday' => 4, 'Thursday' => 5, 'Friday' => 6, 'Saturday' => 7);
	const Number = array('Zero' => 0, 'One' => 1, 'Two' => 2, 'Three' => 3, 'Four' => 4, 'Five' => 5, 'Six' => 6, 'Seven' => 7, 'Eight' => 8, 'Nine' => 9);
}
echo Enum::Day['Sunday'];

But we can’t. So it’s up to the programmer to keep some kind of convention not to change the $enum.

if ($i == 0) {
  echo 'Zero';
} else if ($i == 1) {
  echo 'One';
} else {
  echo 'Does...not...compute...';
}

We can transform the above code using switch statement and still keep the same purpose:

switch ($i) {
  case 0:
    echo 'Zero';
    break;
  case 1:
    echo 'One';
    break;
  default:
    echo 'Does...not...compute...';
}

For a long time I thought that this is the limit of switch statement, comparing a variable to a set of finite values. I thought that switch cannot replace if-then-else when it involves some kind of range.
For example, supposed we have this code:

if ($i > 100) {
  echo 'Good';
} else if ($i > 50) {
  echo 'So-so';
} else {
  echo 'Bad';
}

Can the above code be rewritten using switch statement? Until yesterday I thought it can’t.
But just now I see this technique:

switch (true) {
  case ($i > 100):
    echo 'Good';
    break;
  case ($i > 50):
    echo 'So-so';
    break;
  default:
    echo 'Bad';
}

Brilliant, isn’t it!? I found this technique while I did some code-window-shopping. This technique utilize the PHP switch capability of using any data type.