Useful extensions for Laravel

I’m starting to love Laravel. And while starting new project, there are few extensions I like to use which saves a lot of time. Maybe someone else will find these useful as well.

1. Laravel 4 Generators

A really awesome extension from Jeffrey Way. This makes life easier by creating all the controllers and models with a single command. A must have extension before starting a new application.

2. Confide

Every app requires a decent authentication system. To sum up the required features there need to be a registration process, a log in process, email validation, password recovery etc. This is really tedious to create all those over and over. Confide solves that problem.

3. Entrust

This might not be essential for all applications but it is a very useful one too. This extension creates a role management on Laravel. This is from the same author of Confide and works better with it.

I’ll enrich this list later if I get to love some other useful extension. All the related suggestions are welcome.

CodeIgniter template library

The thing I hate most about CodeIgniter is that the views folder become messed up after a while. So many files and so difficult to track down a view for a certain area of an application. So, to solve that I figured I should create a library to override the ways of managing views. I wrote this very small library to solve the problem. Now I can easily create different templates (or themes whatever you prefer them to call) inside the views. Also I’ve added a layout file (or you can call the master file) in the template for the base structure of the page. So, I don’t have to repeat the areas like header, footer or menu on every view. The library can be download the library from GitHub.

Here I’ve explained how the library works and how to integrate it within a CodeIgniter application.

The library

So, the library is simple consisting only three methods – get, set and view. They does exactly what they are called, get current template, set active template and loads the view respectively. Also I’ve defined the default template, which is used in case template is not set anywhere, at the top of the library.

define('DEFAULT_TEMPLATE', 'default');

You can set the default template in the config file if you like. Let’s jump into the library codes.

First the global variables and constructor of the library.

var $ci;
public function __construct() 
{
    $this->ci =& get_instance();
}

I prefer to load the CodeIgniter instance inside the constructor instead of inside every function. Nothing fancy about it. Next is the get function.

public function get($default = DEFAULT_TEMPLATE)
{
    $template = $this->ci->session->userdata('active_template');
    if($template && $template !== NULL) {
        return $template;
    }
    return $default;
}

We assume that the template name is set in the session. But if nothing was found in the session, we use the default value defined at the top of the library.

In the set function, we just set the template name in the session.

public function set($default = DEFAULT_TEMPLATE)
{
    $this->ci->session->set_userdata('active_template', $default);
    return $default;
}

Remember, our session library must be loaded. I prefer to load it using autoload.php as I use the session a lot.

Finally in the view function, I’ve checked for the existence of the desired view within the template and if the file exists I’ve loaded the view within the layout (master file I’ve mentioned earlier) of that template.

public function view($view = '', $data = NULL, $alternate_template = FALSE, $template = DEFAULT_TEMPLATE, $print = FALSE)
{
    $template_name = $template;
    if(!$alternate_template) {
        $template_name = $this->get();
    } 
    if(strlen($view) == 0 || !file_exists( APPPATH . 'views/' . $template_name . '/' . $view . '.php')) {
        show_error('Unable to load the template: ' . $template_name . '/' . $view . '.php');
    }
    if(!$print) {
        $this->ci->load->view($template_name . '/' . 'layout', array('data' => $data, 'view' => $template_name . '/' . $view));
    }
}

Here I’ve used the $print variable to determine whether to load the view or not. Sometimes I want to handle AJAX calls which should not be sent to output.

Adding template

To add a new template we need to add a directory within the views directory. Every directory within the views are considered as a template. Inside each template there should be a layout.php file and all other views you need. You can put your views within sub directories if you want but the layout.php must stay right within the template directory. So, if I add a new template called mytemplate the directory structure will be like this:

|_ viewes
    |_ mytemplate
        |_ layout.php
        |_ otherview.php

The layout file

The structure of layout.php depends on however the application looks like. We just need to use  $this->load->view($view, $data); wherever we want to output our view’s content. So, a sample layout.php file might look like this:

<!doctype html>
<html>
<head>
    <title><?php echo (isset($data['title'])? $data['title'] : "My Website Title") ?></title>
</head>
<body>
    <div class="wrapper">
        <?php $this->load->view($view, $data); ?>
    </div>
</body>
</html>

Usage

Well, using the library is very easy. Once the library is placed inside the applications library folder and loaded in the controller (though I prefer using autoload.php), we can load a view using  $this->template->view('view_name', $data); in the controller. Now, to organize the views properly we can make sub directories within the template. Let’s say we have an index view for the home controller and an account view for member controller. We can create two folder called home and member within the template folder and then add the views like home/index.php and member/account.php files. Then from the index function of home controller we should call the view like:

$this->template->view('home/index', $data);

And from the account function of member controller we should call the view like:

$this->template->view('member/account', $data);

That’s about it. Download the files from the GitHub repository and I’ve added a sample controller with sample template structure in there.

Advanced object selection using Mootools

Mootools’ “Selectors” utility has some really strong feature. It really saves a lot of time and sweat. Using this property, one can select a tag (any one can!), tag with specific name, id or any other attribute (huh!) and most amazingly part of a property value matching to some string…

Say you want to select all the div tags which has ID starting with ‘my’. How can you do that? Continue reading

Mootools Basics

Mootools is a great JavaScript library and I feel really comfortable using it. There are lot other libraries, like JQuery, DoJo, ExtJS. They have their own features, but I feel strong with Mootools. ExtJs is really good, but very much heavyweight. On the other hand, Mootools is really lightweight. Including all the core features, it is only around 64KB. Special effects may weight around 100KB more.

A most used function of Mootools is the $ function. It’s a bit confusing with JQuery and that’s why conflicts with JQuery if used on the same page. $ selects a dom element from the document by its id. The syntax is $(‘element_id’). There is another pretty good function that I like is $$ function. It selects elements by class name or tag etc. More on this functions are available in Mootools documentation.

Mootools Request feature is another great thing to have. This AJAX calling function is capable of sending AJAX request either in GET or POST method.

These are the basic functions one may need to develop a regular web application. There are also other common helper functions for Array, String, Number, Cookie etc. For detail idea about Mootools, it is suggested to visit Mootools Documentation at http://docs.mootools.net/

One thing to keep in mind. Whenever you are adding some JavaScript code on your documents HEAD, make sure it is inside a document onReady or onLoad function. Otherwise, you’ll get stuck with JS errors. Most of the cases, the common mistake is like using the JS code to get an element at the HEAD, but the body is still loading. So the script couldn’t find the element and throw an error.

For Mootools, this onLoad wrapping syntax is like this:

window.addEvent('domready', function(){
//Your Code Here
});