CodeIgniter is one of my favorite framework and I often use it for developing application quickly. Although it is very flexible in most cases, I find its naming convention to be strict. Many times I have faced this problem when my controller’s class name and a model/library’s class names are the same – a Fatal error is inevitable and I have to forcefully change the name of the conflicting class to something less desirable (say from Users to UsersModel). Today I wanted to end this problem.

So I extended the CI_Router core class and made change to the _validate_request method. Now I can name my controller classes in this fashion: UsersController and it resides on the file system as controllers/UsersController.php. If you’ve tried other established frameworks, you should notice that this naming convention is widely used. So, if you have the same need, then just download the MY_Router.php file and put it on your application/libraries folder. That’s it.

Here is how your controller would start:

<?php

class UsersController extends Controller
{
    public function __construct()
    {
        parent::__construct();
    }
}

If you’d like to have a look at the code, here is the source for quick view:

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');

/*
 * MY_Router
 *
 * Extended the core CI_Router class in order to force a different naming
 * convention for controllers.
 *
 */
class MY_Router extends CI_Router
{
    /*
     * Suffix in controller name
     *
     * @var String
     */
    private $_suffix = "Controller";

    /*
     * Call the parent constructor
     *
     * This is a requirement for extending base CI core class. Just abiding by
     * the rules.
     *
     * @access  public
     * @return  void
     */
    public function MY_Router()
    {
        parent::CI_Router();
    }

    /**
     * Validates the supplied segments.  Attempts to determine the path to
     * the controller.
     *
     * @access   private
     * @param    array
     * @return   array
     */
    function _validate_request($segments)
    {
        // Retain the original segments
        $orgSegments = array_slice($segments, 0);

        // Add suffix to the end
        $segments[0] = ucfirst($segments[0]) . $this->_suffix;

        // Does the requested controller exist in the root folder?
        if (file_exists(APPPATH.'controllers/'.$segments[0].EXT))
        {
            return $segments;
        }

        // OK, revert to the original segment
        $segments[0] = $orgSegments[0];

        // Is the controller in a sub-folder?
        if (is_dir(APPPATH.'controllers/'.$segments[0]))
        {
            // Set the directory and remove it from the segment array
            $this->set_directory($segments[0]);
            $segments = array_slice($segments, 1);

            if (count($segments) > 0)
            {
                // Add suffix to the end
                $segments[0] = ucfirst($segments[0]) . $this->_suffix;

                // Does the requested controller exist in the sub-folder?
                if ( ! file_exists(APPPATH.'controllers/'.$this->fetch_directory().$segments[0].EXT))
                {
                    show_404($this->fetch_directory().$segments[0]);
                }
            }
            else
            {
                // Add suffix to the end
                $this->default_controller = ucfirst($this->default_controller) . $this->_suffix;

                $this->set_class($this->default_controller);
                $this->set_method('index');

                // Does the default controller exist in the sub-folder?
                if ( ! file_exists(APPPATH.'controllers/'.$this->fetch_directory().$this->default_controller.EXT))
                {
                    $this->directory = '';
                    return array();
                }

            }

            return $segments;
        }

        // Can't find the requested controller...
        show_404($segments[0]);
    }
}

Cheers!

Greetings to all the readers of my blog.

Many of you have been writing to me in the last couple days when I took the site down. The main objective was to add the new theme and push a few code updates of the existing libraries. I really appreciate your concern and would like to reassure you that the site is up and will be up as usual Now, besides the slightly customized theme from Elegant Themes, I have put a few code updates. They are detailed below:

Extended Model for CodeIgniter

The original version of the Extended Model for CodeIgniter has been serving many people well. Although most users loved the nifty functions of the Model, many (including me) didn’t like the hacking of CI core to get this functionality. With the release of CodeIgniter 1.7, we can avoid that as we can now overload the Model class of CI like the other libraries. Follow this instruction:

1. Download the updated version from here
2. Put it in your application/libraries folder
3. In your model files, use it this way: class Product extends MY_Model
4. Everything else is same just like the original one

HTTP Class

There is not much update in this class except for a few bug fixes (thanks to you guys). Also, I have included a license file in the package as many of you have asked. It’s released under the MIT license. The original post is here for reference.

Download the update from here and the API reference is here.

Cross-domain AJAX calls using PHP

A minor bug fix in the code. Thanks to a few of you who pointed them out. Original post is here. Download the update from here.

I have accelerated plans for the blog in 2009 so stay tuned for some worthy posts in this month. And do write to me if you feel you have any questions/ideas/suggestions.

Cheers!

Who is this for?

You’ve been developing web applications using PHP for a couple months now and are finding it very enjoyable. Although you feel that you’re doing quite good, you’re not sure whether its the end. Besides, the following questions wonder you often:

• Where to go from here
• What new things to learn
• How to become a Kick-ass PHP Ninja

If that’s the scenario, then this post if for YOU.

Background

A few days back, I read a number of blog posts where people have highlighted the shortcomings they see in newbie developers. Some of them have gone further to narrow down the focus on PHP developers only (as PHP’s nature sometimes allow developers to avoid standards). They did a great job by listing the shortcomings, but their posts missed clear way forwards (these can be inferred though). A number of readers also commented on the posts with their insight as well. So I was thinking how about compiling all these in an easy to follow list? Hence this post.

Btw, due to the volume, I’ve mostly touched the points here and provided few useful resource links for further study. I do have plan to elaborate a few of them in coming posts, with each point becoming a single post. Let me know which ones you’ll prefer most, by entering the poll at the bottom of the post.

Part A : Technical Way Forward

In the first part, let’s shed some light on how you can move forward with your technical abilities.

1. Start using version control

Version control is like a big UNDO button for your coding. You can go back to your previous code revisions and can compare/rollback to specific code areas anytime you see necessary. It will keep track of all your changes and will empower you to track your development changes across your work/team. Also, in a distributed development team, version control helps prevent overwriting of code by team members and keeps all the members code up to date.

Subversion (SVN) is one of the most popular open source version control system. If you’re on windows platform, you can try TortoiseSVN, a client for SVN.

2. Write code in OOP way

If you haven’t already, it’s high time you started writing code in Object Oriented Programming (OOP) way. You may ask why? Well, OOP forces you to write code that is maintainable in nature. If properly followed, OOP code become a lot efficient than procedural code. Also, it allows you to re-use code across your project and/or multiple projects.

If you’re not convinced, have a look at these excellent resources for further study.

3. Adhere to a coding standard

Coding standards allow you to write code in a way which is easily understood by other people. When you adhere to a coding standard used by may others, you actually convey a message that you’re serious in writing code that people will be able to “get” and maintain. Keeping abbreviation type variable names, applying multiple indention types, writing meaningless function names etc will work for you in short term, maybe in personal projects. But when you move to a larger group with a number of developers, you ought to follow a standard so that everybody working with you can get along with your parts.

The following standards are most widely used among PHP developers around the globe:

• PEAR Coding Standards
• Zend Framework Coding Standards
• eZ Publish PHP Coding Standards (depreciated)
• eZ Components Implementation guidelines

Although you can define a standard for your team/company, it’s always better to have close relation with what the industry follows. In my company, Right Brain Solution Ltd, we follow a slightly modified version of Zend Framework Coding Standards. You can get that one here.

4. Document your code

Documentation is a virtue of great developers – don’t get me wrong, I’m talking about code documentation, not writing user manuals Well documented code prevents other team members from reading each line of your code and understand them by heart. Rather, it tells them exactly what they need to know – purpose of the code, what it requires as input, what it will deliver as output, etc. If you take a look at the above mentioned coding standards, you’ll discover that most of them even specified standard for documentation as well, which is phpDocumentor. It’s the most used standard for PHP code documentation and is widely recognized.

5. Use a good framework

Frameworks give you good structure and helps you build web applications in a fast way, with confidence. Most of today’s popular PHP frameworks (Zend Framework, CodeIgniter, CakePHP, Symfony, Kohana etc) follow the Model-View-Controller (MVC) pattern, which itself is a strong advocate of good practice.

Besides structure, frameworks force you to write code in a structured way. Some of them will also require writing the code in OOP – whose benefit we already discussed above. And frameworks usually come with a number of helpful libraries and helpers, to make your life easy as a web developer.

Josh sharp discusses this in details here and later posts a follow-up here. Both are good reads.

6. Re-use code/libraries

One of the most common advice programmers get is: “Don’t re-invent the wheel”. Well, what’s the point here? It actually means that you should not spend much time on solving a problem that has already been solved, in efficient way, by others. Rather solving it out yourself, you can “google” it and see how others have done it. It will not only save your valuable time, but also will ensure stable code (assuming that people usually post things on web after doing a number of testing and user of the codes usually help iron-out any issues, etc).

However, keep an eye on your target use/objective. If there is not enough good solutions that solves your problem, go ahead and solve yourself. Make it good and give it back to the community so that others facing that problem won’t need to spent the time you’ve spent. The whole open source model runs on this give-give way, so be a part of it.

7. Test your code the right way

In order to make confidence out of your code, you’ll need to test your code the right way. Although you might be used to testing your application using debug messages and browser refreshes, in a real world scenario these won’t work. You’ll need to write unit tests which can do automated testing of your code. The power lies in that you can run these tests almost anytime and can check if anything is broken after each new change.

PHPUnit and SimpleTest are the two most widely used Unit testing suite for PHP. You should also have a look on Test Driven Development (TDD), which is the way of greatly enhancing your chance of deploying application with least bugs.

Part B : Personal Way Forward

Now, even if you’ve improved yourself on the above mentioned points, you’ll still need to work on your personal matters to move forward. Here goes those points.

8. Be Agile

You need to be an agile developer if you want to move forward in your career. What does it mean to be agile? Agility is more of an attitude than a skill set. The common characteristics of agile developers are:

• They’re open minded and therefore willing to learn new techniques
• They’re responsible and therefore willing to seek the help of the right person(s) for the task at hand
• They’re willing to work closely with others, pair programming or working in small teams as appropriate
• They’re willing to work iteratively and incrementally

Further resources: Agile Software Development, The Agile Manifesto.

9. Keep yourself updated

No matter what, keep yourself updated on whats going on in your field (in this case PHP). Subscribe to the RSS of great PHP blogs and skim over them on a regular basis. Dig into the topics that interest you most and see the author’s point. Also, keep a habit of trying new technologies every now & then. It gives you an edge over others and when any discussion goes about it, you can help others understand as well as make your points.

Btw, if you don’t have a clue where to find good blogs, have a look at here, here and here.

10. Start community involvement

Remember I told above to give your work back to the community ? How to do that ? Start a blog of your own and start writing posts there every now & then. Yes, I know you’d say “Who’s going to read my blog anyway?”, but if you share your experience, someday, somebody will find it useful. And if you can share things that others haven’t done, you’ll slowly see visitors coming on your blog increasing way.

Besides blog, try to participate in tech forums and communities. Help people out in the areas you excel and at the time of your need, other people will be happy to help you out as well. These communities are also great place to learn about many unusual matters, see how situation changes from person to person, place to place, etc. You’ll also be able to make great friends who might come handy later in your life.

Another great way of community involvement is to contributing to open source projects. Share some of your valuable time for an open source project and it may come handy for a huge number of people. Your work might solve the problem of somebody like you. If needed, initiate an open source project yourself and invite others to work on your vision.

11. Use a good IDE

With due respect to Dreamweaver, step forward and use an IDE made for PHP. You’ll notice the difference in a few days when you’ll see that your productivity has increased in great ways. These IDEs provide great number of useful features including but not limited to: syntax highlighting, auto completion, code suggestions, code snippets, contextual help, code templates, debugging, profiling, etc.

The following IDEs mostly have the similar feature set and can boost your productivity in great ways:

• NuSphere PhpED
• phpDesigner 2008
• Zend Studio for Eclipse

Personally I use NuSphere PhpED 5.2 and I love it in every way. They’ve provided me with a complementary license and I am grateful to them for that. If you’re planning to buy it, let me know and I might find you a discount.

12. Be communicative

In your team/company, try to be as communicative as possible. It reduces a lot of confusions, makes you close to other devs so that you understand them, portrays you as a good person in front of management and overall, helps you enjoy your work. When you’re working together with others, make them feel that you’re there and ready to give whatever it takes. Create a personal brand of yourself.

What’s next?

Phew! It’s quite a good amount of writing in a while I’ve tried to cover most of the items I found to be important. However, there might be some points I’ve overlooked so feel free to post them in the comments. If this helps any one of the developers I intend it for, then I’ll take that the effort is successful.

Thanks everybody, Happy Eid Mubarak to you!

Feb 2009: An updated version of the code for CodeIgniter 1.7.x can be found here.

I developed this extension of CodeIgniter’s Model last year, but never had the chance to publish it. The main purpose of this extension is to make a dev’s life easy. This extension has been used by several of my devs at RBS and has been proved to increase productivity and reduce the number of painful small queries to write. Their enthusiasm has driven me to post this for the CI fans out there.

Without much babble, let’s get into point. I’ve explained the process of installing it and then showed some example uses. For starter, click here to download it. Now follow these steps to get started:

1. Replace the system/libraries/Model.php file with the attached Model.php (CodeIgniter version 1.6.3)

2. For each of your tables, you will need to create a model file in system/application/models.

3. Lets say we have a "products" table whose schema is as follows:

   1: CREATE TABLE `products` (

   2:       `id` int(11) NOT NULL auto_increment,

   3:       `title` varchar(50) NOT NULL,

   4:       `description` text NOT NULL,

   5:       `color` varchar(20) NOT NULL,

   6:       `price` float NOT NULL,

   7:       `category_id` int(11) NOT NULL,

   8:       `featured` char(1) NOT NULL,

   9:       `enabled` char(1) NOT NULL,

  10:       `visits` int(1) NOT NULL,

  11:       `created` int(11) NOT NULL,

  12:       `modified` int(11) NOT NULL,

  13:       PRIMARY KEY  (`id`)

  14:     ) ENGINE=MyISAM;

4. Now we need to create system/application/models/product.php:

   1: <?php  if (!defined('BASEPATH')) exit('No direct script access allowed');

   2:  

   3:     class Product extends Model {

   4:  

   5:         function Product()

   6:         {

   7:             // Call the Model constructor

   8:             parent::Model();

   9:             

  10:             // Load the associated table

  11:             $this->loadTable('products');

  12:         }

  13:  

  14:     }

5. From any controller, you can load the Model as instructed in the CI manual. Here are some sample usage of the model functions:

   1: function products()

   2:     {

   3:         // Load the model in the default way

   4:         $this->load->model('Product');

   5:         

   6:         // Total # of products

   7:         echo $this->Product->findCount();

   8:         

   9:         // Total # of featured products

  10:         echo $this->Product->findCount("featured = 'Y'"); 

  11:         

  12:         // Retrieve ALL the products

  13:         $allProducts = $this->Product->findAll(); 

  14:         

  15:         // Retrive id, title and price of top 10 products (based on popularity) that are enabled

  16:         $topProducts = $this->Product->findAll("enabled = 'Y'", 'id, title, price', 'visits DESC', '0', '10');

  17:         

  18:         // Retrive id, title and price of the 1st most popular product that is enabled

  19:         $topProducts = $this->Product->find("enabled = 'Y'", 'id, title, price', 'visits DESC', '0', '10'); 

  20:         

  21:         // Retrieve the product with id = 1

  22:         $oneProduct = $this->Product->read(1); 

  23:         

  24:         // Retrive the price of the product whose id = 1

  25:         $productPrice = $this->Product->field('price', 'id = 1'); 

  26:         

  27:         // Single array with the titles of all the enabled products

  28:         $productArr = $this->Product->generateSingleArray("enabled = 'Y'", 'title'); 

  29:         

  30:         // Insert a new product in the db

  31:         $newProductId = $this->Product->insert(array('title' => 'New Product', 'price' => '10.99')); 

  32:         

  33:         // Update the price of the newly added product

  34:         $updProduct = $this->Product->save(array('price' => '20.00'), $newProductId); 

  35:         

  36:         // Delete the product

  37:         $this->Product->remove($new_product_id);

  38:     }

7. There are a number of other helpful functions in this file. If you have a careful look, you’ll discover that some of them are really handy.

UPDATE: I forgot to give due credit to the wonderful developers of CakePHP – I’ve taken inspiration from their Model implementation while building this one for CodeIgniter.

Download

Model.php Extended Model for CodeIgniter Downloaded: 2738 times

MORE UPDATE: Download the version for CodeIgniter 1.7.x here.

This is a library designed to run with Code Igniter that allows the application to protect any folder in the webserver using the htpasswd method of Apache. It can also group the users and create group based permission on the folders. The use is very simple: you need to define an array of the users (and array of groups if you need that), tell it where to store the password files and tell which folder to protect. It will do the rest for you. Here goes the function:

It is a small part of the large protection library I have been developing for a membership management application called MemberSmart . This application allows someone to protect their PHP and non-PHP based files residing in a server in a number of ways. Among the methods, the htpasswd is the most easy and convenient one. This application will be released soon by the client I am working for.

Download the library with the example from htpasswd.zip. Here is an example controller highlighting the use of the library.

Md Emran Hasan
Co-founder & CTO
Right Brain Solution Ltd.

A few days back I discovered CakePHP and was very impressed with it. I started to code one of my apps with it but my impression decreased when i wanted to deploy it. After several methods and even communicating in their IRC, I wasnt able to deploy the app – total wastage of my time !!!

My search for a framework thats as easy (or easier ?) as Cake but having smooth deploy feature started again. I heard about Code Igniter before, but didnt give it much attention. Now I decided to visit their site. The one thing that forced me to give attention to it this time was this text on their site:

“If you’re a developer who lives in the real world of shared hosting accounts and clients with deadlines, and if you’re tired of ponderously large and thoroughly undocumented frameworks that require rocket science to understand, Code Igniter might just be the right tool for you.”

I decided to test it out and to my surprise, they are not lying a bit ! I was able to create a site for one client in super-cool way in a lot lesser time than it would actually take without it. While coding the app, I loved CI’s simplicity, its non-geeky style framework functions and their simple usages, the top-notch documentation and a good user base for knowledge searching.

Now I know which framework I should use for my projects. Certainly Cake is more robust framework than CI, but CI beats it by its simplicity. And I also love that !