Brief summary by chapter

The 1st chapter is pretty much for novice users, who may not be familiar with frameworks. In this chapter one will find some fundamental information about frameworks in general, followed by a brief introduction to CodeIgniter.

The 2nd chapter goes through the installation procedure, file and directory structure and some basic configuration. I feel that this chapter lacks the info on how to set up a site using mod_rewrite (without index.php part in URL) - many newcomers are asking how to do this on the official forums, over and over, yet it’s not properly documented.

The 3rd chapter contains some essential information about MVC and how that pattern is realized in CodeIngiter. This chapter explains how to use controllers and access their methods (routing basics), as well as how to use views, models, libraries and helpers.

Starting with chapter 4 the book goes into specific areas of CodeIgniter. The 4th chapter shows how to utilize CI’s Database and Active Record libraries. Here you will find how to set up a DB connection, how to manipulate the data (plenty of examples are included), as well as a full set of SQL statements for a practice DB.

The 5th chapter, primarily, focuses on views. Here you will find out how to assign data to views and then render the result in various ways, as well as how to use multiple/nested views. Also, there is a quick intro to CodeIgniter’s validation library. The most interesting thing in this chapter, in my opinion, is the custom display model, which can save you quite a bit of time and hassle.

The 6th chapter mainly covers CodeIgniter’s security aspects. Here you will find how to securely authenticate a user and process, store and pass session data.
Chapter 7 gives a quick intro to OOP, then jumps into the inner workings of the framework itself (which is OOP based, of course). Here you will find a thorough explanation of CodeIngiter’s object model. Those working in PHP5, however, should note that all objects are already passed by reference.

The 8th chapter covers error logging and handling, unit test library, benchmarking class, and profiler feature. All of the above features are extremely helpful - this chapter can save you a lot of time in tracking and squashing bugs.

Chapter 9 covers FTP, XML-RPC and Email libraries. While you are not likely to use the first two very often, the Email class will come very handy in just about any application.

Chapter 10 has an odd and rather misleading name - “How CI helps to Provide Dynamic Information” - the chapter, in fact, discusses and odd collection of features that are not much related to each other. Here you will find info about date and text helpers, HTML table class, an odd implementation of internalization (the Language class) and finally the caching feature. My guess is that the name should have been - “Simplifying work with dynamic template data” - something like that :)

Chapter 11 focuses on libraries that deal with file operations. The following features are discussed: file and download helpers, upload and file compression classes, as well as image processing library. If you want to create a web gallery or a similar application, then this chapter is for you :)

The 12th chapter discusses various issues that may occur when migrating your application to a production server. You will also find out how to upgrade CodeIgniter to a newer version, as well as extending already existing functionality of core libraries.

Chapter 13 talks about CRUD. In my own experience, CodeIgniter’s built in CRUD is not very useful. However, you may find some extensions, mentioned in the final chapter, to make this feature more useful.

The 14th chapter weighs out pros and cones. Here the author outlines where the framework was useful and where it could use some improvement. Personally, I don’t think that CodeIgniter needs an AJAX class. I do, however, think that validation and internationalization could be greatly improved and generic authorization wouldn’t hurt either.

In the final chapter, the author speaks of additional external resources, which may simplify your life even further. Essentially, there are references to forums, wiki, some video tutorials, some libraries, and some AJAX/JavaScript stuff. From myself, I’d like to add the official video tutorials (I found them most helpful), as well as the official documentation. I don’t, however, recommend any of the mentioned AJAX resources, as they use an obtrusive approach and there are much better ways of integrating JavaScript into CodeIgniter.

Conclusion

If you are an advanced CodeIgniter user, this book won’t do much for you, in my opinion. There aren’t many advanced topics, nor there are any PHP5 specific discussions. However, if you are new to CodeIgniter, then this book is definitely worth reading. Generally, it’s straightforward, but most importantly easy to digest. With this book, you will be able to quickly figure out what exactly CodeIgniter is, and how to efficiently utilize it for your projects.

This benchmark measures ‘out of the box’ performance of the above 3 frameworks. Framework versions are as follows: Cake 1.2.0.6311-beta, CodeIgniter 1.6.1, Kohana 2.1.1 (latest stable releases available at the time of testing). For this test I used a small static ‘hello world’ page, no dynamic elements other than framework internals. I chose not to use frameworks’ built in caching engines, since using them may actually be more expensive (than not using them) for caching static pages. Each benchmark was run 3 times, with the following parameters: concurrency level 5, number of requests 1000 (ab -c 5 -n 1000); the mean of those benchmarks was then derived. Here are the environment specs:

Linux Mint 4.0 (Ubuntu 7.10)
Apache 2.2.4
PHP 5.2.3
eAccelerator 0.9.5.2

The results

Static HTML file served by Apache resulted in 13528 RPS and 11397 RPS with eAccelerator enabled. Finally, here are the benchmarks:

Conclusion

Cake has so many nice features, too bad it’s so incredibly slow - even with eAccelerator enabled, it’s about 30% slower than a plain CI/Kohana installation. Unacceptable. CodeIgniter and Kohana, on the other hand, show great results and come up just about even (330 RPS, 326 RPS respectively) without eAccelerator. With eAccelerator turned on, CodeIgniter is clearly the winner. My wild guess is that eAccelerator does not play so nice with __autoload function, which is widely used in Kohana.

Input array filter

When saving data from web forms, I normally validate and XSS filter all of the necessary elements of the $_POST array and then simply pass it to a model method. The problem is that often, in the $_POST array, there are extra fields that do not exist in the target table (fields used for controller logic - navigation etc). Obviously, trying to insert a field that does not exist in a table will trigger an error. One way around that is to manually unset all of the unnecessary elements in the $_POST array. That solution, however, does not scale at all and the code looks ugly. For that reason, I’ve written a method that will compare input array keys to the target table field names and unset all of the elements that do not match. Additionally, the input array can be passed through the XSS filter; that functionality is turned off by default. Here is the sample code:

Model methods

/**
 * Make sure that the incoming array does not contain any
 * fields which are not in the target table.
 * Additionally, input can be XSS filtered.
 *
 * @access 	protected
 * @param 	string
 * @param 	array
 * @param   boolean
 * @return 	array
 *
 */
protected function filterInputArray($table, $data, $xss_clean = false){
	$fields = $this->db->list_fields($table);

	foreach ($data as $k => $v) {
		if(in_array($k, $fields) == false){
			unset($data[$k]);
		} else {
			if($xss_clean === true) $data[$k] = $this->input->xss_clean($v);
		}
	}

	return $data;
}

//a typical update method
public function updateMethod($id, $data = array()){
	$data = $this->filterInputArray('users', $data);
	$this->db->where('id', $id);
	$this->db->update('users', $data);
	return $this->db->affected_rows();
}

//a typical insert method
public function insertMethod($data = array()){
	$data = $this->filterInputArray('users', $data);
	$this->db->insert('users', $data);
	return $this->db->insert_id();
}

How you would call it from a Controller

public function someMethod(){
	//load and configure validation
	$this->load->library('validation');

	//run validation
	if ($this->validation->run() == true){
		//load the model
		$this->load->model('User_model', 'users');

		//call the insert method
		$user_id = $this->users->insertMethod($_POST);

		//call the update method
		$this->users->updateMethod($user_id, $_POST);
	}
}

Get result as an array

This method is used for generating query results - it always returns an array, even if it’s an empty one. It is built upon active record’s ‘get’ method. Essentially it eliminates the need to check if query has produced any result, as well as the need to call result_array() method. Additionally, by default, the keys in the resulting array will be set to the value of ‘id’ - this can be quite handy when working with arrays generated from dependent tables. Take a look at the code:

Model methods

/**
 * Similar to active record's get method.
 * Will always return an array, even if the query did not yield any results.
 * By default, the reulting array's keys are equal to 'id'. That feature may
 * be disabled by passing false as an optional parameter.
 *
 * @access 	protected
 * @param 	boolean
 * @return 	array
 *
 */
protected function getArray($use_id_as_key = true){
	$res = $this->db->get();

	$items = array();

	if ($res->num_rows() > 0) {
        foreach ($res->result_array() as $k => $v) {
			foreach ($v as $kk => $vv) {
				if($use_id_as_key === true) $items[$v['id']][$kk] = $vv;
				else $items[$k][$kk] = $vv;
			}
		}
	} 

	return $items;
} 

//a typical select method
//can't get much easier that this (except for ORM of course :))
public function selectMethod($id){
	$this->db->from('users')->where('id', $id);
	return $this->getArray();
}

How you would call it from a Controller

public function someMethod($user_id){
	//load the model
	$this->load->model('User_model', 'users');

	//get user by id
	$user = $this->users->selectMethod($user_id);
}

Afterword

The above methods save me a lot of the time and headache, so I hope you find them useful. If you decide to use those in your code, the best place for them would be in a parent model.

The problem

All of the strings in non default character set would show up as a bunch of question marks (привет = ??????). I should note that this happened on my local machine, production server with similar data functioned just fine.

Attempts to fix the problem

If you’re only interested in the solution, you may skip to the conclusion.

Step 1:
Naturally, first thing I did was searching MySQL documentation. The solution was to change default character set by adding the following line to MySQL configuration file:

init-connect='SET NAMES cp1251'

The above line, basically, changes character set at the time of connection.

Unfortunately the above code did not work for me.
Step 2:
Since tweaking MySQL settings did not yield any positive results, I’ve decided to check apache language configuration. I’ve added extra encoding options and changed language priorities – nothing.

Step 3:
Did more searching and found that using SET NAMES command should definitely work from within the script. Gave it a shot and it did, in fact, work. Theoretically, that solves the problem. On practice, however, is not very convenient, nor does it lead to portable code.

Step 4:
I figured that the command SET NAMES worked just fine, but for some reason did not execute from the MySQL configuration file – my assumption was correct.
The script was establishing connection under ‘root’ user, which has all of the privileges – ironically that is what caused the problem. Apparently, any connection established from a user with SUPER privilege, will not trigger init-connect.
Sure enough, creating a user with appropriate privileges solved the problem.

Conclusion

Just to recap – the following things should be done in order to solve the problem:

1. Add the following line to MySQL configuration file, somewhere in [mysqld] section.

init-connect='SET NAMES cp1251'

2. Make sure that your script is connecting with a user that does not have SUPER privilege.

It’s been a while since my last post – my excuse is a complete lack of time, due to high workload. Anyway, just in time for Xmas, I have managed to find some spare time to write a Mootools class that simulates a snowfall.
The class is pretty simple, yet there are many options to play with. Although the title suggests that the snow is comprised of text symbols, you can also use HTML and therefore images, for snowflakes.
Anyway, if this is something that you may be interested in using for the holiday season, here is how you would do it:

<script type="text/javascript" src="js/mootools.v1.11.js"></script>
<script type="text/javascript" src="js/mootools.tsnow.js"></script>

<script type="text/javascript">
//<![CDATA[
var Site = {

	start: function(){
		//basic usage, assumes that div#snow dimensions have been explicitly specified
		//div#snow is the container for the snowfall, needs to be created by hand
		new TextSnow({ container:$('snow') });

		//extended usage, all options are used
		new TextSnow({
			container:$('snow'),//container where you want the snowfall
			inject:'top',//insert stage inside, top, before or after the container

			stage:{
				//any number of css rules
				styles:{
					background:'#ccc',
					width: 100,
					height: 100
				},
				padding: 1//horisontal stage padding
			},

			snow:{
				ammount: 30,//number of snowflakes
				speed:[1,2,3],//speed with wich individual snowflakes fall

				//any number of css rules
				styles: {
					'position': 'absolute'
				},

				symbol: ['*', '.', '<img src="img-url" />', '&raquo;'],//an array of flake symbols, html can be used as well
				color:['#fff','#eee','#eed'],//flake color
				fontFamily:['Impact', 'Times New Roman', 'Georgia'],//different flake shape
				fontSize:[20,22],//font size in pixels
				direction:'left',//left,right,straight
				sinkSpeed:50//how fast the snow is falling (lower number = higher speed)
			}
		});
	}
};

window.addEvent('domready', Site.start);
//]]>
</script>

<!-- CSS used for the example on my site -->
<style type="text/css">
	#snow{height: 500px; width: 750px; position: relative;}
	#snow img{position: absolute; top:0; left: 0;}
</style>

The script can be downloaded here. Oh and Merry Christmas & Happy New Year!

function __autoload($class) {
    //prevent CI and Pear classes from being loaded.
    if(!strstr($class, 'CI') && !stristr($class, 'PEAR')){
        require_once(PATH_TO_LIBRARIES."$class.php");
    }
}

Essentially, by parsing the class name, you can create different loading routines for different libraries. After you’ve set up the __autoload function, call your classes as usual (new, extends, implements and static method calls, should all trigger __autoload).

You can take a look at the demo here. If that’s something you may be interested in, here is how to use it (also check out the demo’s source code for more examples):

<script type="text/javascript" src="js/mootools.v1.11.js"></script>
<script type="text/javascript" src="js/mootools.tds.js"></script>

<script type="text/javascript">
//<![CDATA[

	var Site = {

		start: function(){
			//simple ds with no options
			new TextDropShadow($('element'));

			//all elements with particular class name
			new TextDropShadow($$('element.classname'));

			//set ds color to #222 and it's opacity to 50%
			//when using apacity, you must specify background color or IE will output junk
			new TextDropShadow($('element'), {color:'#222', opacity: 0.5, background: '#fff'});

			//specify color and direction
			new TextDropShadow($('element'), {color:'#222', top:2, left:2});

			//shadow direction can take negative values as well
			new TextDropShadow($('element'), {color:'#222', top:-1, left:-1});
		}

	};

	window.addEvent('domready', Site.start);
//]]>
</script>

The script is available for download here…

Model

The SQL here is based on WP Search Reloaded plug-in. It is a fairly sophisticated way of searching through text, but requires FULLTEXT index. To simplify the example, this query is designed for search with a single term.

/*     

CREATE TABLE `posts` (
  `id` int(11) unsigned NOT NULL auto_increment,
  `title` varchar(255) NOT NULL,
  `body` text NOT NULL,
  `date` timestamp NOT NULL default CURRENT_TIMESTAMP,
  PRIMARY KEY  (`id`),
  UNIQUE KEY `id` (`id`),
  FULLTEXT KEY `title` (`title`,`body`)
) ENGINE=MyISAM DEFAULT CHARSET=latin1;

*/

//search posts table for matching terms - the method will produce an associative array
public function search($term) {
	$term = $this->db->escape($term);

	$sql = "SELECT posts.*,
			CASE WHEN posts.title REGEXP $term THEN 1 ELSE 0 END AS keyword_in_title,
			MATCH ( posts.title, posts.body ) AGAINST ($term) AS mysql_score
			FROM posts
			WHERE ( posts.title REGEXP $term OR posts.body REGEXP $term )
			ORDER BY keyword_in_title DESC, mysql_score DESC, posts.date DESC LIMIT 0, 10";

	$res = $this->db->query($sql);	

	$items = array();

	if ($res->num_rows() > 0) {

		$count = 0;
		foreach ($res->result() as $item) {

			foreach ($item as $key => $value) {
				$items[$count][$key] = $value;
			}

			$count++;
		}
	} 

	return $items;
}

View

This part is straight forward - a form for submitting search requests and a for loop to display the results.

<!-- header -->

<div id="form-container-wrapper">
	<div id="form-container">
		<form method="post" id="ls-form" action="<?php site_url('ajax'); ?>">
			<p>
				<label for="searchterm" class="heading">Start typing in the bessage box. Try <strong>CodeIgniter</strong>, for example.</label>
			</p>
			<p>
				<input type="text" name="searchterm" id="searchterm" value="" />
				<input type="submit" name="Submit" id="submit" value="Submit" />
			</p>

		</form>
	</div><!-- form-container -->
</div><!-- form-container-wrapper -->

<div id="search-results-wrapper">
	<div id="search-results">

	<?php if($posts): ?>
		<h2>Search results:</h2>
		<?php $count = 1; foreach($posts as $key => $post) : ?>

		<h3><?php echo $count; ?>. <?php echo $post['title']; ?></h3>
		<p><?php echo $post['body']; ?></p>

		<?php $count++; endforeach; ?>
	<?php else: ?>	

		<h2>Search results:</h2>
		<p>Your query did not match any posts.</p>

	<?php endif; ?>	

	</div><!-- end search-results -->
</div><!-- end search-results-wrapper -->

<!-- footer-->

Controller

Controller contains one key method that will render the related view upon a standard post request or dump a JSON encoded string upon an AJAX request. You will need the JSON library for CodeIgniter to encode/decode that notation - the lib is provided further down the page.

public function index(){
	$this->search('standard');
}

public function json(){
	$this->search('json');
}

public function search($transport = null){
	//load database
	$this->load->database();
	//load posts model
	$this->load->model('Posts', 'posts');
	//load JSON lib
	$this->load->library('JSON', 'json');

	//init posts array
	$posts = array();

	//validate and filter the input
	if(isset($_POST['searchterm']) && !empty($_POST['searchterm'])){
		//clean the string, just in case
		$searchterm = strip_tags($_POST['searchterm']);
		//get the results if any
		$posts = $this->posts->search($searchterm);
	}

	//if request came from a JSON application
	if($transport == 'json'){
		//output the encoded string
		echo $this->json->encode($posts);
		//and exit, no reason to continue
		exit;
	}

	//assign post array
	$this->data['posts'] = $posts;
	//display the view
	$this->render('livesearch');
}

JSON Library for CodeIgniter

This is a wrapper for Services_JSON class from JSON’s official website. The library has two methods encode and decode, simple. You can download this library from CodeIgniter’s WIKI. To use the library, simply drop the contents of the zip file into the library folder in the application folder (not the library folder located in system).
If you have PHP 5.2.0 or older, the above library will not be needed. As of PHP 5.2.0, the JSON extension is bundled and compiled into PHP by default.

JavaScript

Finally after the application is completely functional, we can look into the fun part - Mootools :) The JS part of the application sends an AJAX post request containing the search term(s) and in return receives an encoded JSON string. The string is then decoded using Mootools JSON parser. The resulting JS object is then used to build and display the search results.

<script type="text/javascript">
//<![CDATA[
	var Site = {

		start: function(){
			Site.liveSearch();
		},

		liveSearch: function(){
			//set focus on the search form
			$('searchterm').focus();

			//attach a keyup event to the searchfield
			$('searchterm').addEvent('keyup', function(event){

				//controller's URI
				var url = '<?php echo site_url('livesearch/json'); ?>';

				//AJAX request
				new Ajax(url, {

					method: 'post',
					onComplete: function(request){
						//prepare search container for new results
						$('search-results').empty();

						//if controller returned some results decode them
						if(request) var results = Json.evaluate(request);
						//pass results object to the output method
						if(results) Site.buildSearchResults(results);
					},
					//post search form
					postBody: $('ls-form')				

				}).request();

				//return false;
			});
		},

		buildSearchResults: function(results){
			//prepare the container for newly fetched results
			var container = $('search-results');
			var heading = new Element('h2').setHTML('Search results:').injectInside(container);

			//output the results
			results.each(function(result, i) {
				var title = new Element('h3').injectInside(container);
				var link = new Element('a', {'href': '#post-'+result.id}).setHTML((i+1)+'. '+result.title).injectInside(title);
				var body = new Element('p').setHTML(result.body).injectAfter(title);
				var br = new Element('br').injectAfter(body);
			});
		}

	};
	window.addEvent('domready', Site.start);
//]]>
</script>

Further reading

Applying slide effect to a single element is straight forward and looks something like this:

var collapsible = new Fx.Slide($('target-element'), {
	duration: 500,
	transition: Fx.Transitions.linear
});

collapsible.toggle();

What’s not immediately obvious is that, the code above takes the target element and wraps it into a div with overflow set to hidden. Whenever Fx.Slide is toggled, negative margin is applied to the target element and it, sort of, slides under the wrapping div. Take a look at the HTML before and after the effect was applied:

<!-- before the effect is applied -->
<li>
	<div  class="collapse">
		<p>Some text here</p>
	</div>
</li>

<!-- after slideIn effect was applied -->
<li>
	<div style="overflow: hidden; height: 0px;">
		<div class="collapse" style="margin: -100px 0 0;">
			<p>Some text here</p>
		</div>
	</div>
</li>

<!-- after slideOut effect was applied -->
<li>
	<div style="overflow: hidden; height: 100px;">
		<div class="collapse" style="margin: 0;">
			<p>Some text here</p>
		</div>
	</div>
</li>

Once you understand how Fx.Slide functions, it becomes clear that this effect cannot be applied to any particular target more than once. With that in mind, the solution for collapsing or expanding all items is quite simple – store all of the Fx.Slide references in an array, then upon a request loop through the array and for each element in it, apply the desired effect. Here is the code:

//list of target elements
var list = $$('#collapse li div.collapse');
//list elements to be clicked on
var headings = $$('#collapse li h3');
//array to store all of the collapsibles
var collapsibles = new Array();

headings.each( function(heading, i) {

	//for each element create a slide effect
	var collapsible = new Fx.Slide(list[i], {
		duration: 500,
		transition: Fx.Transitions.linear
	});

	//and store it in the array
	collapsibles[i] = collapsible;

	//add event listener
	heading.onclick = function(){
		collapsible.toggle();
		return false;
	}

	//collapse all of the list items
	collapsible.hide();

});

//collapse all
$('collapse-all').onclick = function(){
	headings.each( function(heading, i) {
		collapsibles[i].hide();
	});
}

//expand all
$('expand-all').onclick = function(){
	headings.each( function(heading, i) {
		collapsibles[i].show();
	});
}

Also, by adding just a few more lines of code we can simulate an accordion:

headings.each( function(heading, i) {

	//for each element create a slide effect
	var collapsible = new Fx.Slide(list[i], {
		duration: 500,
		transition: Fx.Transitions.linear
	});

	//and store it in the array
	collapsibles[i] = collapsible;

	//add event listener
	heading.onclick = function(){

		//open current element
		collapsible.toggle();

		//hide the rest
		for(var j = 0; j < collapsibles.length; j++){
			if(j!=i) collapsibles[j].slideOut();
		}

		return false;
	}

	//collapse all of the list items
	collapsible.hide();

});

Take a look at the source code of the demo page to see more elaborate code examples.

A massive honey bee, harvesting a blooming green onion

See the original (~3.5Mb).

Neat tiny flowers, which I suspect may be giving me allergies :)

See the original (~3.7Mb).

Thus far I’m very impressed with the controls, as well as camera’s excellent performance. The autofocus, however, is a bit disappointing – it seems incapable of focusing on some things that my old camera had absolutely no problems with. I suspect it has something to do with the particular lens that is being used at the moment. To make any conclusions about it, I’d have to play around with the camera a bit more, see how it behaves with other lenses.

There are some more macro shots from this set, available at Kartinka.

]]>