Weblog of Nirandas

Using Smarty with codeigniter

Niran — Sat, 14 Mar 2009 07:39:59 +0000

If you like to use smarty for designing your views while developing codeigniter applications, just read on. Smarty is a powerful templating engine for php. Its template language is simple yet powerful. By default, codeigniter doesn’t use any templating system. Instead it relies on plain old php for designing views. Integrating smarty into codeigniter is rather simple. First, download the latest smarty version and copy the libs folder into /system/application/libraries/.

Now create a new file “View.php” inside the /system/application/libraries folder. Note: the case of the filename is important it must be “View.php”. Now put the following code inside the View.php file.

require_once(dirname(__FILE__).’/libs/Smarty.class.php’);

class View extends Smarty{

public $layout=’default’;

function __construct(){

parent::__construct();

$this->compile_check = true;

$this->debugging = false;

$this->template_dir = APPPATH.’views’;

$this->compile_dir = APPPATH.’temp’;

}

function show($name){

$content=$this->fetch($name.’.tpl’);

$this->assign(’content’,$content);

$this->display(’layout/’.$this->layout.’.tpl’);

}

Point of interest:

We have a member variable on our view class which will hold the name of the layout template. By default it is set to ‘default’.

In the constructor, we are telling smarty where to look for our view templates and where to save the compiled version of our templates. Smarty will look for views in /system/application/views/ and it will save the compiled templates inside the /system/application/temp/ folder. Please do set the required permissions on the /system/application/temp/ folder enabling Smarty to write to it.

We will be calling the show() function of our view class for rendering the views. The $name parameter should be the path to the view without the “.tpl” extension. For example:

$this->view->show(‘site/login’);

Inside the show () function, we are fetching the output of the view specified using the following line

$content=$this->fetch($name.’.tpl’);

Then, we are assigning the output of the view to a smarty variable named ‘content’

$this->assign(’content’,$content);

Finally, we are displaying the layout template using the below line

$this->display(’layout/’.$this->layout.’.tpl’);

Now our layout template should use the assigned variable ‘content’ for outputting the contents of the view captured earlier. For example

…

{$content}

…

Neat! Instead of views including the headers and footers they need, now we have a common, site wide layout template much like ASP.NET’s master pages. The layout template must be placed inside a folder named “layout” inside the /system/application/views/ folder.

Using the view class

For using this new view class, you must load the View library using

$this->load->library(‘view’);

Or you can auto load the view library so that you do not have to load it in each controller action. Once the view class is loaded either through auto loading or using code, use the similar code as shown below for displaying views.

$this->view->assign(’name’,’nirandas’);

$this->view->show(’hello’);

All methods of the Smarty object are available to us through $this->view variable. For assigning variables we can use

$this->view->assign(‘var_name’,’var_value’);

And for displaying our pages we can use

$this->view->show(‘view_name’);

Beginning Reflection.Emit, a basic example

Niran — Fri, 16 Jan 2009 13:49:38 +0000

The System.Reflection.Emit namespace provides us the tools required to generate .NET code on the fly. Especially the DynamicMethod class makes the job of creating small code snippet easier. In this post I’ll show a simple example of dynamically creating a method which takes a string as its argument and returns a string “hi “prepended to it. First, we will create the DynamicMethod object specifying the argument list and the return type of the dynamic method. Next we will emit the MSIL required to do the task, yes, we can only create dynamic methods using MSIL. Then we will create a delegate from our dynamic method. Then we can call the delegate like we would do with any delegate.

Okay, let us declare the delegate first

//Delegate matching the method to be generated
delegate string SayHi(string name);

Now, let us look at the actual code:

//create the DynamicMethod object
DynamicMethod method=new DynamicMethod(”method”,//Method name
typeof(string),//The return type
new Type[]{typeof(string)},//array of types specifying the type of arguments and their order
typeof(Program).Module //The module to which the method will be connected
);
//Create the IL generater
ILGenerator il=method.GetILGenerator();
//Load the const string “hi ” on to the evaluation stack
il.Emit(OpCodes.Ldstr,”Hi “);
//Load the argument, the name
il.Emit (OpCodes.Ldarg_0 );
//call the string.Concat() with 2 string parameters
il.EmitCall(OpCodes.Call,
typeof(string).GetMethod(”Concat”,new Type[]{typeof(string),typeof(string)}) ,//Find and pass the overload of Concat which accepts 2 strings
null );
//return, effectivly returning the result of string.Concat()
il.Emit(OpCodes.Ret);
// Complete the IL generation and create a delegate
SayHi hi=(SayHi)method.CreateDelegate(typeof(SayHi));

//execute our generated method with “nirandas” as the parameter
MessageBox.Show(hi(”Nirandas”));

For more information about dynamic method creation, visit this MSDN page.
Happy coding!

Determining if a Type implements an interface

Niran — Tue, 13 Jan 2009 05:08:57 +0000

If we have an object of a type, we can easily check if that object implements a particular type by using is operator.

if(o is IExample)

Console.WriteLine(“Yes”);

Here the If statement will evaluate to true if the object o implements the interface IExample or the object is a derived object of IExample.

However, we cannot use is operator if all we got is a type and we want to find whether that type implements a particular interface.

Type.IsAssignableFrom()

The System.Type class has an IsAssignableFrom() method which does exactly what we want. The IsAssignableFrom() method takes a type as its argument and returns true if the object of the provided type can be assigned to a variable of the current type. See the following example:

interface IExample

{

void Do();

}

class Example : IExample

{

#region IExample Members

public void Do()

{

throw new Exception(“The method or operation is not implemented.”);

}

#endregion

}

Here we are declaring an interface IExample and a class Example which implements the IExample interface. Now let us see how we can check that the type Example implements IExample interface.

if(typeof(IExample).IsAssignableFrom(typeof(Example)))

Console.WriteLine(“Yes”);

This will output “yes” to the console as the interface IExample is implemented by class Example class. For more information on Type.IsAssignableFrom() method, visit this MSDN page.

Happy coding!

Basics of PHP

Niran — Mon, 12 Jan 2009 16:56:07 +0000

What is PHP?

PHP is a high level scripting language particularly used in developing websites. PHP is very powerful and easy to learn. PHP is platform independent that is, PHP can run on either Linux or Windows and many other OS. Unlike C or C++, PHP is an interpreted language that is, the PHP code we write doesn’t get converted into machine code. Instead the PHP reads and executes the source code when we run the script. For more information about PHP and its history, visit http://en.wikipedia.org/wiki/PHP

PHP and web server

For creating websites, PHP must be installed and configured on the server hosting the website. Although any modern web server can be configured to run PHP and serve PHP websites, the most widely used combination is Linux, apache, MySql and PHP or jointly known as LAMP. On Windows platform, we can install PHP and configure IIS for accepting requests for PHP. Or we can install WAMP, a single package containing apache, MySql and PHP for Windows and use it instead.

Web request lifecycle

When we request a page through any web browser, the browser creates a specially formatted message (HTTP Request) and sends to the URL we requested. On receiving the request from the client, that is the browser, server invokes the PHP engine and provides the information about the page requested. Now the PHP engine reads our PHP file, parses it and execute the PHP code inside the file. After the execution the output of our script is send back to the client. The whole communication between web browser and the web server is governed by the HTTP protocol, a common language by which browser and server exchange information.

PHP hello world

From now on, we will look at actual code examples. So I expect you have installed and configured PHP or you have access to a properly configured PHP environment.

Create a file under the web server’s root and save the following code in it. Name the file as “hello.php”.

Listing 1.1

Echo “Hello world”;

Let us examine the code. The first line, indicates the start of PHP code block. The “?>” on the third line indicates the closing of the previously opened code block. PHP only executes code found inside these code blocks, anything outside of these code block is not parsed and printed on the page as it is. For example consider the following code snippet:

Listing 1.2

hello world example 2

echo “hello world!”;

Will output following to the browser:

Listing 1.2.1

hello world example 2

hello world!

There can be 0 or more such PHP code blocks on a single page. Now the second line in the listing 1.1, echo “Hello world!”; does the actual work of printing the text “Hello world!” to the webpage. The echo and print statements are used for writing to the output. Another thing to notice is that PHP requires that we should terminate each PHP statement using a ’;’ symbol.

Summary

PHP is a free, platform independent, scripting language. PHP is interpreted on the runtime not compiled as some traditional languages like C/C++ are. Also PHP can be setup to work with almost any web server including IIS and apache.

The PHP code is written inside files with .php extension. We use special markers to differentiate code from normal text by enclosing the code inside it.

Failing tests as a reminder of unimplemented requirement

Niran — Tue, 16 Dec 2008 11:09:51 +0000

I am a new comer to the art of unit testing and it has not yet become the part of my coding routine. However, even this early I have realized how useful writing unit tests can be. Specially writing unit tests gives you the understanding how the class will be used and where the errors can arise etc. For example passing the Type System.String to a method where the method expects a Type which implements a particular interface ICommand should result in an error because the System.String does not certainly implements the interface ICommand. But does the method validate the input?

Now writing a test for this case is very simple. Just create the object, call the method with System.String as the Type parameter.

[Test]
[ExpectedException(typeof(ArgumentException))]
public void CanNotRegisterTypesNotImplementingICommand()
{
CommandLocater locater=new CommandLocater();
locater.RegisterCommand(1,typeof(string));
}

Certainly I haven’t implemented the validation code for checking this, so the test is certainly failing. Until I feel like doing this validation, this test will always fail. Lot better than forgetting to write this code and getting an unrelated exception in any other section of the code is getting a failing test which will make sure that I’ll write the code necessary to implement this requirement.
“Always write tests to break your code.”

Sorting list the easy way using lambda expressions

Niran — Mon, 15 Dec 2008 06:41:37 +0000

Introduction of lambda expressions in .NET 3.5 have simplified many operations. One of them is sorting List<t> of complex types. For example assume that we have a type named Person and it has a Name property among other properties. Now if we want to sort a list of List<Person> on the Name property, we just have to use a single line of code.

list.Sort((p1,p2)=>p1.Name.CompareTo(p2.Name));

Or to sort on the Age property

list.Sort((p1,p2)=>p1.Age.CompareTo(p2.Age));

Here we are creating a delegate of Comparison<Person> using lambda expression and passing it to one of the overload of sort () method which accepts a Comparison<t>. The following code is breakdown of the above one liner into 2 lines.

Comparison<Person> pc=(p1,p2)=>p1.Name.CompareTo(p2.Name);
list.Sort(pc);

In short, we can use lambda expression to create delegates inline and pass them where ever a delegate can be passed. The List<t> class itself has many methods where you can pass delegates to perform certain actions. For example List<t>.ForEach() method.

list.ForEach(o => Console.WriteLine(o.Name));

Here we are outputting the names of persons in the list to the console without using a foreach loop.

Always explicitly detach explicitly attached event handlers

Niran — Sat, 06 Dec 2008 16:16:12 +0000

We extensively use events in our .net programs. Most of the times, it doesn’t give you debugging worries. However in some cases, it can become an issue where your object containing event handler doesn’t get garbage collected due to event raising object holding a reference to the listener object. This happens when you listen to the events from a long lived object compared to the listening object.

If you are coding in VB.NET then using the handles clause will guard you to an extent. Just remember to set the withevents variable to nothing after done. This will remove bindings between your event handlers and the object.

However, if we are programming in C# or have to use AddHandler statements in VB.NET for attaching event handlers, remember to explicitly detach the handler from the event.

As I said earlier, most of the times this does not become an issue at all. However, while creating highly event driven classes for your application, you don’t want objects sticking around more than they need to be. Also since the handler is still attached to the event, the handler will get invoked each time the event is fired. You can think the issues arising when this happens.

Keep an eye on how you attach event handlers and make sure that you are detaching them in time.

Is it OK to not have explicit return statements in functions?

Niran — Wed, 12 Nov 2008 04:41:07 +0000

Simple answer: no. There are basically two types of methods in .NET world. First those do not return any values (void methods in C# or subroutines in VB). Second those methods which do return some values (non void methods in C# and functions in VB)

So, failing to have a return statement where the calling code expects one, should be reason enough to cause a compilation error. Not so in VB.NET 2005, at least not with the default configuration.

Couple of days ago I spend few minutes understanding this same issue. Yes, not explicitly returning any value from a function is a huge programming error. But it becomes even worse when you don’t get to know it until runtime.

The value returned to the caller when there isn’t any explicit return statement in the code is the default value for the return type of the function. Or in other words, the result will be as if you have returned nothing. For example, if you have following function in your code:

Private Function test() As Integer

End Function

Then somewhere else have this statement:

MessageBox.Show(test.ToString())

The program will compile normally and produce a message box with 0 (the default value of integer) in it. If we change the return type of the test method to string, the function will be returning nothing (return nothing) the default value for any object.

Does anyone know any way around this issue, any changes to configuration? So that VB.NET compiler becomes stricter? Yes, it isn’t such a problem. But still, the compiler should alert us to such silly mistakes which we may make time to time.

hide email and other sensitive information from spam harvesters

Niran — Thu, 16 Oct 2008 16:28:10 +0000

Often we have to display email addresses and other contact information on our pages. For example providing a mailto link etc. However, along with the intended users, some other persons/bots are also interested in getting those email IDs for sending spams. For this, spammers use special bots for harvesting email/contact info from the web. In this post, I will show a method using javascript and any server side language by which we can easily protect such important information.

example

The following c# code sample demonstrates the use of this code. The server side:

It is how the code will look like on the client side

document.write(JsDecrypt({value:"%u00c2%u0097%17%3aw%u00ea%u00cdu%0f1K%u00a2G%u008a%0d%u00e3%u00fb%02%02",key:93 }));

When this script gets executed on the client side, the email id “example@example.com” will be printed to the document. Naturally, for it to work, the JsDecrypt() function should also be included in the page.

How it works?

It is simple, the server side code encrypts the information and encodes it in JSON, javascript object notation, and sends it to the client. There our java script function JsDecrypt() decrypts the message and returns the original message. A special thing is that the key used is generated randomly while encrypting the message and is included in the JSON returned. The client side script uses that key for the decryption process. Hence, the same message would generate different outputs depending upon the randomly generated key.

Naturally the encryption method used is not the strongests however, it is more than enough for preventing the email spam bots. Also the code as it is, will only work with ascii characters (not tested with unicode).

code

The code for this javascript decrypter has two parts. 1. The server side code for encrypting the data. The server side code can be in any language even in php. The only thing to remember is that the decrypter and encrypter version should be the same. 2. The client side javascript for decryption. The client code follows.

The JsDecrypt() function takes an object with two properties. 1. The encrypted data. 2. The key used for encryption. Then the function decrypts the data using the key and returns the result. Note

The encryption function discussed below returns the encryption result as required by the JsDecrypt() function. You only need to pass it directly to the JsDecrypt() function for decrypting.

The server side code

The server side code can be in any language as long as the generated result is as per the format required by the JsDecrypt() function. I have included code for asp.net (c#) and php. asp.net code follows.

asp.net version

//version:1.0
//the javascript decrypter version should also be 1.0
public string JsEncrypt(string data)
{
int Key=new Random().Next(0,256);
int StartingKey=Key;
string output=string.Empty;
for(int i=0;i

php version

//version:1.0
//the javascript decrypter version should also be 1.0
function JsEncrypt($string)
{
$const=rand(0,255);
$key=$const;
$output='';
for($i=0;$i

creating GUIDs in .net

Niran — Mon, 13 Oct 2008 12:58:09 +0000

After an interval of more than 2 weeks, I am back online blogging. Today I will share a quick tip on how to create a guid in C# and vb.net. For a description about GUIDs, visit this Wikipedia page.

A guid in the .net world is represented by the System.Guid class. The Guid class has many constructors which takes 0 or more arguments and constructs a guid from it. However, if we want to create a random guid, using the parameter less constructor would not do. A guid created using the parameter less constructor contains all zeros. So how to create a unique guid?

Guid.NewGuid() method

The Guid class has a static method named NewGuid() which creates and returns a new random guid. Let’s see a example.

C#

Guid g=Guid.NewGuid();
                             MessageBox.Show(g.ToString());

VB.NET

Dim g As Guid =Guid.NewGuid()
                             MessageBox.Show(g.ToString())

Here we are simply creating a new guid and using ToString() method for displaying it. You can also get byte representation of the guid using ToByteArray() method.

Enjoy!