One of the brighter aspects of the Zend Framework is that it has many cool libraries. The framework itself is loosely tied and the components are available as stand alone. We can take this opportunity to integrate the powerful library of the Zend Framework into the beautiful CodeIgniter making ourselves more productive than before. Specially, we can relieve ourselves from writing and maintaining wrappers to different APIs.

Ok then, let’s see how do we integrate the Zend Framework libraries into CI.

1) Setup CodeIgniter.

2) Download the Zend Framework. Extract the archive.

3) From the ZF files, copy the “Zend” directory from inside the “library” directory.

4) Paste the directory into the “system/application/libraries” directory. So ultimately, the new location of the copied “Zend” directory would be “system/application/libraries/Zend”. If you’re on Linux/Unix, we need to deal with file permission. Make the Zend directory accessible by all. I don’t think I need to tell you how to do that with chmod, do I ?

5) In the same “system/application/libraries/” directory, create a new file named “Zend.php” and put the following contents:

 
<?php if (!defined('BASEPATH')) {exit('No direct script access allowed');}
 
class Zend
{
 
	function __construct()
	{
 
		ini_set('include_path',
		ini_get('include_path') . PATH_SEPARATOR . APPPATH . 'libraries');
 
	}
 
 
	function load($class)
	{
		require_once (string) $class . EXT;
 
	}
}
 
?>

We are done. That completes the integration. Now we can load any Zend component inside our controllers. Let’s make our hands dirty by modifying the default welcome controller. Open the “system/application/controllers/welcome.php” and put the following contents:

<?php
 
class Welcome extends Controller {
 
	function Welcome()
	{
		parent::Controller();
	}
 
	function index()
	{
		 $this->load->library('zend');
		 $this->zend->load('Zend/Service/Flickr');
 
		$flickr = new Zend_Service_Flickr('12e99caebb8f305fff5a943606ecde18');
 
		$results = $flickr->tagSearch('worldcup');
 
 
 
		foreach ($results as $result)
		{
 
                      $photo = $result->Small;
                      echo "<a href=\"{$photo->clickUri}\"><img src=\"{$photo->uri}\" /></a><br /><br />";
 
		}
 
	}
}
?>

If you read the codes above, you already know what it does If everything goes right, you’ll see a bunch of Flickr photos with the “worldcup” tag. Clicking on a photo will take you to the Flickr page of that photo.

Now, what we have seen is pretty straightforward. We don’t use any hooks or don’t go for any complexity. We simply put the Zend library in the application library. Then we write a loader class that loads Zend libraries. When we construct this “Zend Loader” object, it adds the Zend library directory to the include path. Then when we use the load() method of the object, it imports the library and adds the functionalities to the current scope

Enjoy the Zend Services with the cool CodeIgniter framework! Have fun

After Googling a while, I just learned a magic trick that can emulate this feature in Netbeans. The process is pretty simple. We feed Netbeans a php file that has a simple sample “Controller” class definition that has phpdoc specifying the necessary properties. We put this file in a place readable by the IDE by invisible or worthless for the CodeIgniter framework. The “nbproject” directory inside the project root could be a good place to put this file. What really happens is that Netbeans reads the phpdoc and offers the completion of the specified properties in any class that extends the Controller class. Hiding it from CodeIgniter helps not to mess up with the system.

This is what I did. I created a php file and named it “nb.php”. I filled this file with the following contents:

<?php
/**
* @property CI_Loader $load
* @property CI_Form_validation $form_validation
* @property CI_Input $input
* @property CI_Email $email
* @property CI_DB_active_record $db
* @property CI_DB_forge $dbforge
* @property CI_Table $table
* @property CI_Session $session
* @property CI_FTP $ftp
* ....
*/
Class Controller {
}
?>

And put the file inside my nbproject directory. Now I am getting code completion in my Netbeans for CodeIgniter.

$model = $this->model->table_name;

To find a specific entry, use the find() method of the model object. Example:

$result = $model->find("id='10'"); // find the entry with ID 10

Remember that the columns are returned as associative arrays or dictionaries. To get the email address of the data marked by ID 10, we use:

$email = $result['email'];

Though I believe that it’d have been better if the resultset was an object as well. Then we would have been able to grab the email address by typing:

$email = $result->email // This is not possible yet

I have an work around it. Just cast the resultset into an object using this following code:

$result = (object)$result;
$email = $result->email; // Now it works :)

Well, having an associative array is not bad, but it’s cooler to have an object

If you are obsessed about OOP, take the advantage of the model class definition and override the find() method to return an object.

Suppose we have a table named “users” which we will convert into a model. Go to the “app/models” directory and save the following file as: usersmodel.php

<?php
 
class usersmodel extends activemodel {
 
	public function find($p) {
 
		$res = parent::find($p); // call the parent class's find() method
		$res = (object)$res;  // cast the array into an object
		return $res; // return the object
 
	}
 
}
 
?>

Now you are done You can now use the “users” model as following:

$model = $this->model->users;
$res = $model->find("id='2'");
$email = $res->email;

Cool, isn’t it ? Orchid is really fantastic when it comes to flexibility. I love it !

Methods:

Once you have retrieved or constructed a resultset, you can use the following methods to interact with the database:

clean() — Cleans all values of a model’s fields.
delete() — Delete the row that contains the current resultset.
insert() — Once you have added values to each of the fields, use this method to insert the data.
update() — Updates the resultset with altered data.
find() — Finds and returns a single resultset based on the given condition.
findAll() — Finds all the results based on the condition.
findById() — Finds a single resultset based on the “id” field.
save() — Similar to update, it saves the resultset into the database.
join() — For complex queries having “joining” operations.

PS: There are lots more functionalities in Orchid models. Hasin vai taught me many of the fantastic features that the models in orchid have. But unfortunately, I have lost many of those information from my memory. I’ll have to check my chat history or ask Hasin bro again when I need those functionalities. But mainly these techniques described above would do most of my database related tasks.

I examined the sample apps for a while but since I have no prior experience in a whole framework like Orchid, I was having a tough time understanding how the wheel rotates inside Orchid. But I could ocassionaly make some educated guesses and my asking Hasin vai proved that all of them were correct I was now more comfortable at exploring this new Island that at first seemed to be so full of vicious creatures.

After a while, I realized that I am that sort of stupid who can’t understand theories until he has done some practical work. I decided to do something on my own. While browsing the source, I found a “cli.php” in the root directory of Orchid. Those who know me or have read enough of blogs, they’d know that I am badly fascinated by cli tools. Examining the cli.php file, I could figure out that this one creates skeleton codes for an app. The cli tool has two options — create a skeleton app or an app with pre-installed controller and views. I chose the second option.

First, I removed the samples those came bundled up with Orchid. Then I opened up my terminal and fired off typind the following codes:

cd /home/masnun/www/orchid/
php cli.php controller masnun

That’s all I needed. First one changed the current working directory to the Orchid directory. The second one invoked the Orchid CLI tool to create a controller for “masnun”. Again, I should criticize Hasin Vai, the CLI tool prints nothing but a single line saying — “Welcome to the CLI tool of Orchid” or something like that. Though it gives an error message on failure, I don’t think thats any credit of the tool in question, rather the error message is generated by PHP itself. On the other hand, on success, you get not even a single line congratulating you or at least saying “hi”. I am very much offended by such rudeness

Anyway, I was now ready to view my app at: http://localhost/orchid/masnun/

It showed a simple text saying “Called from masnun/base method”. That made sense to me. There is a “base” method inside the “masnun” controller. I opened up the controller file and yeah, there really was a base method and another method named “hello” I was curious to see, what this other method does. So, I visited out of curiosity the following URL:

http://localhost/orchid/masnun/hello/

The result was somehow obvious, yeah it printed “hello world!”.

Now I came to think about it. How does Orchid work ? Well, I was feeling stupid now, since it has now been quite clear. The URL format is:

/controller/method.

If you just visit the controller, the base method is called. That is:

“/controller/” == “/controller/base/”

It was easy as pie! Then I moved on to using templating. Opened up the view directory and found two files — “base.php” and “hello.php”. I had no doubt that they had markup for each of the method of the controller. I opened up the controller again to examine.

$this->view->set("name","masnun");

Aha… I don’t even have to explicitly define the view ? Cool… Hasin vai really has some talent then Every method auto loads the curresponding view That cuts down the work of a programmer for sure. But wait! How can Hasin vai be this stupid ? What if I need to setup a different view ? Oh my god! I have to tell him about this.

I was frustrated with Orchid and closed the current working copies and started examining the sample apps. At that time, I realized that Hasin vai was not stupid at all, he’s a genius ! He does have the “setView()” method. I was relieved and feeling sorry for cursing the gentleman for a while. But still, I would defend myself because if Hasin vai had a good documentation, I would have known it long before and didn’t need to curse him at all. So, you see? It’s his fault after all and he does deserve some curses for not having a total documentation. What do you say ?

I immediately used the following code in the hello method:

$this->setView("base");
$this->view->set("name","masnun");

Wow ! It does work. I have been able to reproduce the base method view just by changing the view of the hello method. I am damn happy.

Later I found out that, there’s a “layouts” folder inside the “views” directory where I can define the global layout for a controller. I created a “masnun.php” in the layouts directory and put these code:

<html>
<head>
<title>Orchid</title>
</head>
<body>
<?php echo $layoutdata; ?>
</body>
</html>

Cool ! The template was applied to the whole controller — that is to both the base and hello method.

I am just loving this framework! Orchid has some cool built in libraries for additional features. Have a look at it’s core features:

1. Support for Caching
a. SQLite Based Caching
b. MySQL Caching
c. Memcached Caching

2. Built in Unit Testing Support
3. Fast and Lightweight
4. Support for MySQL, MySQLi, SQLite, MSSQL and PgSQL using Native DAL and PDO
5. Support for Layout
6. Active Record
7. Easy Application Setup
8. Flexible Configuration Management
9. Builtin Profiling
10. I18N support
11. Session Manager (Native and DB Based)
12. Excellent support for benchmarking and profiling
13. Builtin JSON Encoder and Decoder
14. Google Chart API Support
15. Bundled JS Libraries with Gzip Support
a. Prototype
b. JQuery
c. SWFObject
16. Builtin Library for jQuery Effects and AJAX Support

PS: I am still learning Orchid and hope to keep posted about my progress. I am now concentrating on understanding the models system of Orchid A big thanks to Hasin vai for this wondeful framework !

I have noticed that since I used “url” as an internal variable in the framework engine, it’d mess up if someone used “url” in the GET method. So I changed the internal code to replace “url” with something very cryptic and now I believe that you can use the framework without any hassle.

Still, if you find some sort of bugs or have some suggestions, please let me know,

Keeping all these in head, I started re-writing the MWF from scratch. This time I have managed to build a fully functional URL router that is smart enough to support regular expression. I have also managed to create a templating system for it. Though it’s nothing cool if you compare to the popular frameworks, it does serve my purpose.

I have included a MIT license in this release and uploaded it to my google code repository for downloads.

Download: http://masnun.googlecode.com/files/mwf.zip

How to use it?
Using it is quite simple. You’ll find a demo inside the downloaded package.

It doesn’t have any models. Just URL routing and templating for now.

– First include the library.
– Map the URLs to callback functions. These URLs are matched using regex and if matches the path is sent to the callback function as the only parameter. We define the URL routes as comma separated pairs. I could use a dictionary but I liked this way. I have found it fun while exploring web.py. First the URL pattern, then the callback function for it, then another pattern and it’s call back function, another pair in this way and it goes on…

– Start the web app.

– Define the callback functions.

Sample

<?php
 
include('mwf.php'); // include the library
 
// route the urls. first the url, then the callback function name
// url pattern supports regex
// matched url will be sent to the  callback function as the only parameter
 
$urls = array("/masnun","redir","/tag/[\w]+","home");
 
// done. run the webapp
mwf_run($urls);
 
// Define the callback functions which work as controllers
 
function home($path) {
/*
 
To render a template, feed the function with a php file
and an associative array of key-value pairs (dictionary)
 
 */
template_render('views/layout.php',$dic = array("tag" => $path));
}
 
 
function redir($path) {
// Use the mwf_redirect() function for url redirection
mwf_redirect("/tag/home");
}
 
?>

That’s it… Quite simple…

Download Link: http://masnun.googlecode.com/files/nicedog.zip

I found the official website down and then retrieved the cached copy of the website from Google. There I found the project link to GitHub and managed to download a copy of the framework. The features are really good except that the template rendering system was a bit weird and I could not make it work. So I hacked the core and fixed things to suit my way. It just works fine for now though I had to get rid of “base template” functionality.

Since I liked the framework, I uploaded a copy of the modified version to my google code repository.

How to work with it ?

The following code adds the regex to catch URL in the format:

http://localhost/tag/anytext/

And calls the ‘index’ method of ‘Test’ object if the HTTP request was GET.
Quite like web.py, isn’t it ?
The Controller class, in this case, the Test class should always extend the built in class “C”.

To use template, just use render() method of the object. It’d pass all the variables defined under the object to that file. You just need to echo the variables in the target template file.

The framework has no “models”. So it’s not a MVC. But since it’s based on PHP, we can do without any models, handcrafting the database oriented codes.

<?php
 
require 'NiceDog.php';
R('tag/(?P<tag>[-\w]+)')->controller('test')->action('index')->on('GET');
class Test extends C{
public $tag;
    public function index($tag){
	$this->tag = $tag;
	$this->render('views/layout.php');
 
    }
}
run();
 
?>

Source of the template file:

 
<h1>My firs example</h1>
<?php echo $tag; ?>

Conclusion: NiceDog is not a fully fledged framework. It’s in fact a nano PHP framework for small projects that require less features and small over head.

web.py includes a built in web server to develop an application locally. But I am a Google fan and was thinking of deploying web.py on Google App Engine. I believed GAE and web.py together can help me put up a web app in minutes. And so did they…

The first question came to my mind was “How am I going to install web.py on my GAE account ?”. Well, it was pretty easy in the end. Just extract the web.py package and put the “web” directory inside your application directory. That is the “web” directory would be in the same directory where the app.yaml file resides. Now, in app.yaml file, map all URLs to a single python file. In my case, it was “main.py”.

Now develop the application in the normal web.py way. “It’s easy as pie!” — I thought. But it was not that easy in fact. I had to make a couple of changes.

The app I wrote didn’t do what I expected it to. Rather it raised an “import error” Later, I found out that I have to use “web.application.cgirun()” method instead of the normal “run()” method.

Then I reloaded the app. But this time I got an “internal server error”. After visiting the web.py cookbook, I found out that, to use web.py templates on GAE, I have to compile all templates using the “web/template.py –compile templates” command. I did so. All my templates were compiled into python source code. Cool !

Now my app was running smooth and working fine ! So, at last I made it… Yahoo ! I am loving python, web.py and Google App Engine together

PS: I am using web.py 0.3 where I have the cgirun() method. In older versions of web.py, you have to be tricky. In that case, please consult this thread:

http://bit.ly/EoVyM

Here’s the source code (Without the template):

#!/usr/bin/env python
 
import web
urls = ("/(.*)","site")
 
class site:
	def GET(self,path):
		render = web.template.render('templates')
		return render.masnun(path)
 
app = web.application(urls,globals())
 
def main():
	app.cgirun()
 
if __name__ == '__main__':
  main()

Here’s the “templates/masnun.htm”:

$def with (name)
<html><head><title>web.py demo</title></head><body>
You requested: <b> $name</b></body></html>

There is mainly two applications here à “app” and “viewapp”. The “app” application maps “/view” url to the “viewapp” application while the later handles any request passed to it [ "/(.*)" ] and prints out the requested url.

This can be helpful for creating well structured URLs like http://localhost/view/1034 which will retrieve the article ID 1034 from the database.

Here’s the code:

import web
class view:
    def GET(self,path):
        return path
urls2 = ("/(.*)","view")
viewapp = web.application(urls2,globals())
urls = ("/view",viewapp)
app = web.application(urls,globals())
if __name__ == "__main__":
    app.run() 

The project is still in beta and currently it can only map incoming requests. You need to build URIs as functions. Analyzing the incoming request, the framework calls the corresponding fuction.

<?php
include “mwf.php”;
$webapp = new MWF();
$url['/regex/'] = “home”;
$webapp->map($url);
?>

<?php function home() {?>
<html>
<head><title><?php echo $_SERVER['REQUEST_URI']; ?></title>
</head>
<body><b>You requested:</b> <?php echo $_SERVER['REQUEST_URI']; ?><br /></body>
</html>
<?php } ?>

In the above code snippets, we see MWF in action. Here, we instantiate the MWF. Map the ‘/regex/’ URI to the “home” function. When a visitor requests the URL http://yoursite.com/regex/, the home() function will be called. In our example the function serves a HTML document. You can also generate other mark ups or simply put some HTTP responses yourself. But remember, the script can not recognize static files. In case of delivering a static file, you have to define it’s URI in the URL map and create a function that serves the file manually. I will give an example of that in a future post.

The MWF class has a default notFound() method which handles any situations where the requested URI is not mapped. You may extend the class and modify this method to define your own 404 page or put some HTTP response.

The URL map still doesn’t support regex. But if I get good response (I am not that convinced that I will get any), I will work on that as well.

The .htaccess file is required and you must have .htaccess support enabled on your host for the framework to operate.

DOWNLOAD LINK: http://php.masnun.com/mwf.zip

Files Included:

• .htaccess (Apache HTACCESS Conf)
• mwf.php (Contains the MWF class)
• index.php (The Sample Application)