Downloading the class

Before we begin you need to download the PHP class from below the link below or from the Google code site.

Testing the class

The Translation class used cURL to access the Google translation service, so you need to have that installed. A quick way to check if the class is working correctly is to use the ’selfTest’ method of the class.

<?php
 
require_once('googleTranslate.class.php');
 
$gt = new GoogleTranslateWrapper();
$gt->selfTest();
 
?>

Which will print ‘Test Ok’ if everything is working fine.

Translating text

Once you are sure that the class is working properly, you can use the following simple example to translate a piece of text from one language to another.

<?php
 
require_once('googleTranslate.class.php');
 
/* Initialize the class translate class */
$gt = new GoogleTranslateWrapper();
$sampleText = "Bonjour de cette partie du monde";
 
/* translate(string, to_language, from_language) */
echo $gt->translate($sampleText , "en", "fr");
 
/* This should print 'Hello from this part of the world' */
 
?>

The first parameter of the ‘translate()’ method takes the text to translate, the second and third parameters take the target language to translate to and the language to translate from, respectively. You can eliminate the third parameter, the language name to translate from, and Google will automatically detect the source language and translate the text. This can be useful if you are not sure of the source language but want to translate and also detect the same. A short example is given below. The following will convert the sample text and also detect the source language (French here).

<?php
 
require_once('googleTranslate.class.php');
 
$gt = new GoogleTranslateWrapper();
$test = "Bonjour de cette partie du monde";
/* Convert from English */
$gt->translate($test, "en");
echo $gt->getDetectedSource();
 
?>

Errors during translation

If the class fails to translate the text for some reason, you can read the error message using the following:

.
.
echo $gt->getLastError();
.

Passing valid credentials

Although the class works without you providing a apiKey - using a key in your application/site is completely optional, Google recommends adding your API key and a IP address during the translation request. This helps Google detect valid requests coming from your site and helps it in contacting you in case a need arises. You can signup for the api key here.

You can pass a API key and a IP address using the following.

<?php
 
require_once('googleTranslate.class.php');
 
$apiKey = "YOUR API KEY";
/* Change to your IP address */
$ip = "127.0.0.1";
 
$gt = new GoogleTranslateWrapper();
 
$gt->setCredentials($apiKey, $ip);
$test = "mon nom est Sameer";
echo $gt->translate($test, "en");
 
?>

This concludes the short tutorial on using the ‘GoogleTranslateWrapper’ class.

Readers feedback will be valuable regarding color scheme, content, formatting or any additional features, which will help me make the site more user friendly.

http://www.mycodetools.com/

Logging Wordpress SQL queries

By default Wordpress doesn’t log any queries. But you can instruct Wordpress to do so by adding the following configuration option to your Wordpress ‘wpconfig.php’ file.

/* wp-config.php */
 
define('SAVEQUERIES', true);

Once that is done you can add the following lines at the end of your Wordpress themes ‘footer.php’ file.

/* footer.php */
..
global $wpdb;
print_r($wpdb->queries);
.
.

This will display the SQL statements executed by your Wordpress installation in a raw format as shown below. It displays a total of three items - the executed query, the execution time of the query and the function that called the query.

Array
(
    [0] => Array
        (
            [0] => SELECT option_name, option_value FROM wp_options WHERE autoload = 'yes'
            [1] => 0.004619836807251
            [2] => require, require_once, require_once, require_once, is_blog_installed, wp_load_alloptions
        )
 
    [1] => Array
        (
            [0] => SELECT option_value FROM wp_options WHERE option_name = 'sidebars_widgets' LIMIT 1
            [1] => 0.0015749931335449
            [2] => require, require_once, require_once, require_once, do_action, call_user_func_array, wp_widgets_init, register_widget, WP_Widget_Factory->register, WP_Widget_Recent_Comments->WP_Widget_Recent_Comments, is_active_widget, wp_get_sidebars_widgets, get_option
        )
.
.

As you can see the raw information is not interesting to look at and it also clutters the actual site. A better way is to use FireBug and FirePHP to log the SQL queries without interfering with the Wordpress output.

Installing FirePHP

Before starting you need to have FirePHP and FireBug installed. FirePHP uses FireBugs console window to output the debug messages. Once you have installed FirePHP and FireBug, you need to install the FirePHP server libraries. Copy the FirePHP server libraries to your Wordpress themes directory. For e.g ‘wordpress\wp-content\themes\default\FirePHPCore’.

If you are unfamiliar with FirePHP a nice tutorial can be found at Six Revisions.

Displaying formatted information with FirePHP

Once we are done with the above setup, you can add the following code at the end of your Wordpress themes ‘footer.php’ file, replacing the code we previously added.

<?php
 
    /* footer.php */
 
    require_once("FirePHPCore/FirePHP.class.PHP");
 
    global $wpdb;
 
    $query_table[] = array("SQL", "Execution Time", "Calling Function");
    $expensive_query_time = 0;
    $expensive_query = "";
    $total_time = 0;
 
    foreach($wpdb->queries as $query)
    {
        $query_table[] = array($query[0], $query[1], $query[2]);
        /* Get the most expensive query */
        if($query[1] > $expensive_query_time)
        {
            $expensive_query_time = $query[1];
            $expensive_query = $query[0];
            $total_time += $query[1];
        }
    }
 
    $total_queries = count($wpdb->queries);
    $firephp = FirePHP::getInstance(true);
 
    /* Display the queries in a formatted table */
    $firephp->group('Query', array( 'Collapsed' => false,  
                                    'Color' => '#000'));
    $firephp->table($total_queries . " queries took " . 
                    $total_time . " seconds.", $query_table);
 
    /* Display the query summary */
    $firephp->group('Query Summary', array( 'Collapsed' => false,  
                                            'Color' => '#000'));
    $firephp->log($total_queries, 'Total Queries');
    $firephp->log($expensive_query, 'Expensive Query');
    $firephp->log($expensive_query_time, 'Expensive Query Time');
 
?>
</body>
</html>

Refresh your Wordpress page and you should see the following output in the FireBug console. Click on the image below to view the complete debug screen. (Some queries have been removed for size.) As you can see FirePHP displays a nicely formatted output than the previous one.

Modifying the query data returned by Wordpress

Wordpress by default saves and returns the following three parameters for each SQL query:
1. SQL query
2. Query Execution time
3. The method chain that called the query.

The code section where this happens is located in the query() method of the ‘wp-db.php’ file in the Wordpress ‘wp-includes’ directory. The following snippet shows that section of code:

/* wp-db.php */
.
.
// Log how the function was called
$this->func_call = "\$db->query(\"$query\")";
 
// Keep track of the last query for debug..
$this->last_query = $query;
 
// Perform the query via std mysql_query function..
if ( defined('SAVEQUERIES') && SAVEQUERIES )
    $this->timer_start();
 
$this->result = @mysql_query($query, $this->dbh);
++$this->num_queries;
 
if ( defined('SAVEQUERIES') && SAVEQUERIES )
    $this->queries[] = array( $query, $this->timer_stop(), 
                              $this->get_caller() );
 
.
.

You can modify the code to add some extra parameters as per your requirements, or modify the format in which it is returned. For example you could add code to save the data to a xml or csv file for latter retrieval and analysis.

Note: Turning on the define(’SAVEQUERIES’, true) option can slow down your Wordpress site, so make sure you disable it after your work is done.

Installing the GAPI class

The following code uses the GAPI - Google Analytics API PHP Interface to help us access the Analytics data. So before proceeding you need to download the class file from the GAPI home.

Dimensions & Metrics

Before we start a small primer on Google Analytics Dimensions & Metrics will be helpful.

What is a dimension?
Dimensions are things like browser and country, browser versions, landing and exit pages, the URL of a page, and the source website a visitor has come from.
Google Analytics uses the following 5 main marketing dimensions for analysis:

* Source
* Medium
* Term
* Content
* Campaign

What is a metric?
Metrics are the quantitative measure of a dimension for specific data types, such as counts of new visitors, page views, unique page views etc.

Getting the Google Analytics data

Now that we have seen what Dimensions & Metrics are we will proceed with an example. In this example we will fetch the ’source’ dimension, which shows the source website the visitor is coming from and the ‘visits’ metric. This tells us how many visitors are coming from a particular source to our site.

<?php
 
require 'gapi-1.3/gapi.class.php';
 
/* Set your Google Analytics credentials */
define('ga_account'     ,'YOUR ANALYTICS EMAIL');
define('ga_password'    ,'YOUR ANALYTICS PASSWORD');
define('ga_profile_id'  ,'ANALYTICS SITE PROFILE ID');
 
$ga = new gapi(ga_account,ga_password);
 
/* We are using the 'source' dimension and the 'visits' metrics */
$dimensions = array('source');
$metrics    = array('visits');
 
/* We will sort the result be desending order of visits, 
    and hence the '-' sign before the 'visits' string */
$ga->requestReportData(ga_profile_id, $dimensions, $metrics,'-visits');
 
$gaResults = $ga->getResults();
 
$i=1;
 
foreach($gaResults as $result)
{
    printf("%-4d %-40s %5d\n",
           $i++,
           $result->getSource(),
           $result->getVisits());
}
 
echo "\n-----------------------------------------\n";
echo "Total Results : {$ga->getTotalResults()}";    
 
?>

Below I’ve listed the top ten results of the output.

No.  Source                                   Visits
------------------------------------------------------
1    google                                   10549
2    (direct)                                  1484
3    stumbleupon.com                           1338
4    webintenta.com                             159
5    bing                                       142
6    yahoo                                      115
7    feedburner                                  97
8    phpdeveloper.org                            70
9    t3n.de                                      64
10   clearspace.openqa.org                       43

As you can see the main method in the class is the ‘requestReportData()’, which has the following structure:

function requestReportData($report_id,      
                           $dimensions, 
                           $metrics, 
                           $sort_metric=null, 
                           $filter=null, 
                           $start_date=null, 
                           $end_date=null, 
                           $start_index=1, 
                           $max_results=30)

You can get the Dimension and Metric result by prefixing ‘get’ to the dimension or metric name. For e.g, if you metric name is ‘region’, you can get the result by using:

$result->getRegion();

Although I have only provided a single Dimension and Metric in the example code, the $dimensions and $metrics parameter can take multiple parameters as shown below:

$dimensions = array('source', 'region');
$metrics    = array('visits');

Bear in mind to specify a valid ‘dimension-metric’ combination as given in the API Docs. Specifying an invalid combination will return 0 results.

The output after adding the ‘region’ dimension is shown below.

No. Source     Region               Visits
-----------------------------------------
1   google     (not set)              965
2   google     England                796
3   google     California             650
4   google     Maharashtra            343
5   google     Karnataka              340
6   google     Tamil Nadu             295
7   google     New York               225
8   google     Andhra Pradesh         189
9   google     Texas                  172
10  google     Ontario                165

Modifying the amount of results returned

By default the class returns the first 30 results, although the raw Google API returns 1000 results by default. You can increase the same by changing the $max_results parameter. Google Analytics returns a maximum of 10,000 results, even if you set the $max_results parameter above 10,000. To get the results above that limit you need to set the $start_index parameter to 10,000, which will then get the results starting at 10,000.

$ga->requestReportData(ga_profile_id,
                       $dimensions,
                       $metrics,
                       '-visits', // Sort by 'visits' in descending order
                       '','','', // We are not using this paras yet
                       1,  // Start Index
                       500 // Max results
                       );

You can get the total number of results by using the getTotalResults() method. This can be helpful in pagination.

$ga->getTotalResults();

Setting the Google Analytics report period

By default the class returns the data for the last 1 month from today if no report period is specified. You can specify the report period as below. The date format is in the form ‘YYYY-MM-DD’.

$ga->requestReportData(ga_profile_id,
                       $dimensions,
                       $metrics,
                       '-visits', // Sort by 'visits' in descending order
                       '',
                       '2009-10-01', // Start Date
                       '2009-12-31', // End Date
                       1,  // Start Index
                       500 // Max results
                       );

Filtering the data

You can further filter the results using the $filter parameter. Filtering is a little tricky, so be sure to read the Google documentation.

$filter = 'country == United States';
 
$ga->requestReportData(ga_profile_id,
                       $dimensions,
                       $metrics,
                       '-visits', // Sort by 'visits' in descending order
                       $filter, // Filter the data
                       '2009-10-01', // Start Date
                       '2009-12-31', // End Date
                       1,  // Start Index
                       500 // Max results
                       );

You can also combine various options:

$filter = 'country == United States && visitorType == New Visitor';
// OR
$filter = 'country == United States &&
           visitorType == New Visitor &&
           browser == Firefox';

Getting a list of your Google Analytics Accounts

Most users have more than one profiles in their Analytics account. You can easily get a list of all your accounts (sitename - profileid) with the following code.

<?php
 
require 'gapi-1.3/gapi.class.php';
 
/* Set your Google Analytics credentials */
define('ga_account'     ,'YOUR ANALYTICS EMAIL');
define('ga_password'    ,'YOUR ANALYTICS PASSWORD');
 
$ga = new gapi(ga_account,ga_password);
 
$gaResult = $ga->requestAccountData();
 
foreach($gaResult as $result)
{
  printf("%-30s %15d\n", $result, $result->getProfileId());
}
 
?>

With this we conclude this post. It will be quite helpful if you go over the below references if you are unfamiliar with the Google Analytics API.

Update

Webresourcesdepot features a nifty little application using the above to dispay the Google pageviews in a Feed-burner style chicklet display.

References:
a. Google Analytics Data API - Data Feed
b. Dimensions & Metrics Reference
c. Filters

$var1 = 'a';
$var2 = 'b';
$var3 = 'c';
$var4 = 'd';
 
if(isset($var1) && isset($var2) && isset($var3) && isset($var4))
{
    // All variables are set, do something
}

We can write:

$var1 = 'a';
$var2 = 'b';
$var3 = 'c';
$var4 = 'd';
 
if(isset($var1, $var2, $var3, $var4))
{
    // Will return TRUE only if all of the parameters are set
}

Same with the unset() construct:

unset($var1, $var2, $var3, $var4);

Selenium IDE offers many useful commands (often called Selenese) for testing purposes. You use this sequence of commands to create various tests. But many times these commands are not sufficient and you need to add your own custom commands. For example a reader recently requested on how to input unique email ids for testing. Of course you can easily do this using the Selenium RC server and a language like PHP or Java. But we want to accomplish this in the IDE itself.

Types of Selenium commands

Selenium commands come in three varieties : Actions, Accessors and Assertions. Each Selenium command being given in the format below:

Actions are commands which in general modify the state of the application; click, typeKeys, deleteCookie etc. are all actions. Many actions also come with a sibling with a “AndWait” suffix added; e.g. ‘typeKeysAndWait’. This tells Selenium to wait until the page loads after performing the particular action.

Accessors examine the state of the application and store the results in variables, e.g. “storeLocation”.

Assertions are like Accessors, but they verify that the state of the application conforms to what is expected

In this post we will see how to write Selenium Action command using a simple example.

Writing your first custom Selenium Action Command

In the following example we will add a new action, ‘typeRandomEmail’, which generates a random email address and types it in an input field.

Every Selenium Action command starts with a ‘do’ prefix. The corresponding action comprising ‘AndWait’ is automatically registered. e.g when we create the ‘typeRandomEmail’ action, the ‘typeRandomEmailAndWait’ command is automatically added to the command list. An action command takes up to two parameters, which will be passed the second and third column values in the test table. In our example we will be using only one parameter - the locator id where the random email will be typed.

The following shows the code for the typeRandomEmail action.

 
Selenium.prototype.doTypeRandomEmail = function(locator) {
    /**
    * Sets the value of an input field to a random email id, 
    * as though you typed it in.
    *
    * @param locator an <a href="#locators">element locator</a>
    */
 
    // All locator-strategies are automatically handled by "findElement"
    var element = this.page().findElement(locator);
 
    /* The following block generates a random email string */
    var allowedChars = "abcdefghiklmnopqrstuvwxyz";
    var stringLength = 8;
    var randomstring = '';
 
    for (var i=0; i<stringLength; i++) {
        var rnum = Math.floor(Math.random() * allowedChars.length);
        randomstring += allowedChars.substring(rnum,rnum+1);
    }
 
    // Append a domain name
    randomstring += "@somedomain.com"
 
    // Replace the element text with the new text
    this.browserbot.replaceText(element, randomstring);
};

Importing your custom commands in Selenium

Now that we have completed writing our own action command, it is time to import it to the Selenium IDE. Your custom commands are usually added to the file ‘user-extensions.js’. By default the ‘user-extensions.js’ file does not exist, so you need to first create a blank file into which you will add the above code. Once that is done you then need to tell Selenium to load the particular extension file from the ‘Options’ menu.

Once you have added the file to the options page you need to restart the Selenium IDE for the changes to take effect.

Whenever you add some new code or make changes to the exiting one in the ‘user-extensions.js’, you need to restart the Selenium IDE for the changes to take effect.

Now once you have restarted the IDE, you can see that your command has been added to the drop-down.

Writing other Action commands

You may be wondering how to go about writing other Selenium Action commands; what the this.browserbot object means and where it is defined. Although no clear documentation exists, the Selenium source code can itself be a valuable tool. All the Selenium commands are stored in the ’selenium-api.js’ file. I have included it here for easy download and reference. The original source file and other support files are located in the ’selenium-ide.jar’ file in your Selenium installation directory. Unzip that file and you have all the Selenium source code at your disposal.

Dependencies in PHPUnit tests

PHPUnit 3.4 now supports dependencies between different test methods. It allows you to execute a particular test ONLY IF the test that it depends on executes successfully. Take the following example (Listing 1.) where we test a linked-list class I developed earlier.

A simple unit-test with PHPUnit

The test basically creates a link-list with 100 nodes, and tests a few class methods - reverseList, deleteFirstNode, deleteLastNode. As you can see the linklist creation part and method tests are combined in the single test method testLinkList().

The primary focus here is on testing the three class functions. There is nothing wrong with this. But what if the linklist creation part itself fails before the other tests are conducted? Of course we can add another test to check that the links are being created correctly, but that mixes up the two parts.

Listing 1.

<?php
 
require_once 'linklist.class.php';
require_once 'PHPUnit/Framework.php';
 
class LinkListTest extends PHPUnit_Framework_TestCase
{
    /* How many nodes to create */
    private $_nNodes = 100;
 
    public function testLinkList()
    {
        /* Linklist creation block */
        $theList = new LinkList();
 
        for($i=1; $i <= $this->_nNodes; $i++)  
        {
            $theList->insertLast($i);
        }
 
 
        /* 
            Linklist methods testing block :
 
            $theList->totalNodes() is a public function 
            in the 'linklist' class that returns the total
            number of nodes in the link-list.
        */
 
        $theList->reverseList();
        $this->assertEquals($this->_nNodes, $theList->totalNodes());
 
        $theList->deleteFirstNode();
        $this->assertEquals($this->_nNodes - 1, $theList->totalNodes());
 
        $theList->deleteLastNode();
        $this->assertEquals($this->_nNodes - 2, $theList->totalNodes());
    }
}
 
?>

Splitting up tests

A better way is to split the linklist creation part and class method testing part into two separate test functions as below (Listing 2). Here the linklist is created in the ‘testCreateList()’ method and the testing of the class methods is done in the ‘testLinkList()’ method. This allows us to keep the two testing blocks separate.

Listing 2.

<?php
 
require_once 'linklist.class.php';
require_once 'PHPUnit/Framework.php';
 
class LinkListTest extends PHPUnit_Framework_TestCase
{
    /* How many nodes to create */
    private $_nNodes = 100;
 
    public function testCreateList()
    {
        $theList = new LinkList();
 
        for($i=1; $i <= $this->_nNodes; $i++)
        {
            $theList->insertLast($i);
        }
        $this->assertTrue(!empty($theList));
 
        return $theList;
    }
 
    /**
     * @depends testCreateList
     */
    public function testLinkList($theList)
    {
        $theList->reverseList();
        $this->assertEquals($this->_nNodes, $theList->totalNodes());
 
        $theList->deleteFirstNode();
        $this->assertEquals($this->_nNodes - 1, $theList->totalNodes());
 
        $theList->deleteLastNode();
        $this->assertEquals($this->_nNodes - 2, $theList->totalNodes());
    }
}
 
?>

The important point to note here is that we have specified that the ‘testLinkList‘ method depends on the ‘testCreateList‘ method, with a @depends annotation. This tells PHPUnit that if the ‘testCreateList‘ test fails then the test dependent on it, ‘testLinkList‘, will have to be skipped, which is a logical way to go.

/**
 * @depends testCreateList
 */

Producers & Consumers in a Test

First some definitions:

a. A producer is a test method that yields its unit under test as return value.
b. A consumer is a test method that depends on one or more producers and their return values.

What it means is that a ‘Producer’ is a test method that returns some data that will be used by a ‘Consumer’ test method. In our example the ‘testCreateList‘ is a Producer and the ‘testLinkList‘ is the Consumer. The ‘testCreateList‘ method returns a linklist object which is then received by the dependent method ‘testLinkList‘. So if for some reason the ‘testCreateList‘ fails to return some data then the test that depends on it, ‘testLinkList‘, will have to be skipped, as it has nothing to work with.

Bear in mind that it does not mean that every test method that depends on some other method has to accept some arguments from the method it is dependent on. Lets breakup the above example further (Listing 3). Here we have added one more test method, ‘testNodesDefined‘, which makes sure that the ‘$_nNodes’ variable is not null. The ‘testCreateList‘ method is dependent on this method, so that if the ‘$_nNodes’ is null then the ‘testCreateList‘ is skipped, which causes the test ‘testLinkList‘ to be skipped.

Listing 3.

<?php
 
require_once 'linklist.class.php';
require_once 'PHPUnit/Framework.php';
 
class LinkListTest extends PHPUnit_Framework_TestCase
{
    /* How many nodes to create */
    private $_nNodes = 100;
 
    public function testNodesDefined()
    {
        $this->assertNotNull($this->_nNodes);
    }
 
    /**
     * @depends testNodesDefined
     */
    public function testCreateList()
    {
        $theList = new LinkList();
 
        for($i=1; $i <= $this->_nNodes; $i++)
        {
            $theList->insertLast($i);
        }
        $this->assertTrue(!empty($theList));
 
        return $theList;
    }
 
    /**
     * @depends testCreateList
     */
    public function testLinkList($theList)
    {
        $theList->reverseList();
        $this->assertEquals($this->_nNodes, $theList->totalNodes());
 
        $theList->deleteFirstNode();
        $this->assertEquals($this->_nNodes - 1, $theList->totalNodes());
 
        $theList->deleteLastNode();
        $this->assertEquals($this->_nNodes - 2, $theList->totalNodes());
    }
}
 
?>

A output from a failed test, when we set ‘$_nNodes’ to null, is shown below.
Listing 4.

D:\localhost\datastructures>phpunit --verbose LinkListTest
PHPUnit 3.4.2 by Sebastian Bergmann.
 
LinkListTest
FSS
 
Time: 0 seconds
 
There was 1 failure:
 
1) LinkListTest::testNodesDefined
Failed asserting that <null> is not null.
 
D:\localhost\test\datastructures\LinkListTest.php:13
 
There were 2 skipped tests:
 
1) LinkListTest::testCreateList
This test depends on "LinkListTest::testNodesDefined" to pass.
 
 
2) LinkListTest::testLinkList
This test depends on "LinkListTest::testCreateList" to pass.
 
 
FAILURES!
Tests: 1, Assertions: 2, Failures: 1, Skipped: 2.
 
D:\localhost\test\datastructures>

Note: The tests are executed in the sequence in which you wrote them. So take care while writing dependent tests. For example, sequencing test methods as below will not work.

    public function testNodesDefined()
    {
        $this->assertNotNull($this->_nNodes);
    }
 
    /**
     * @depends testCreateList
     */
    public function testLinkList($theList)
    {
        ..
    }
 
    /**
     * @depends testNodesDefined
     */
    public function testCreateList()
    {
        ..
    }

What all of this has brought us

Testing a complex class in a single humongous test method is not wrong, but can create a confusing mess of ‘asserts’. Splitting a single test method into multiple dependent tests can help you segregate your test methods by functionality which in turn will get you to quickly localize defects in your code.

As a small reminder, below are six of the most important expectations the client has from the developed software, every other thing hinges on these:

1. Revenue generation from the new application
2. Cost reductions from the new application or upgrade
3. Indirect revenue generation
4. Increase in exiting user base due to some new features
5. Increase in market share
6. Revenue increase in companion application

The points raised above may come as common-sense; but how many times when developing for a client, have you given thought to these matters. We developers and usually busy thinking about the best way to structure the application, the best way to run a SQL query, the best MVC framework; leaving the business and value aspects of the proposed software to the management; who usually do not find it prudent to enlighten the developers’ in that matter. It’s not that the technical issues are not important; what is wrong is the predominant focus on technical issues.

Taking the business and value aspects into consideration during development enables you to view the project from the clients perspective. This in itself makes taking decisions regarding certain technical issues easier. It is even more important for you to take the business issues into consideration if you are a freelance developer, where you are solely responsible for bad project outcome, unlike a company where you can play the blame game and walk away from the mess unscathed.

In a nutshell, a client does not care if you have used the latest MVC framework, or used your expert programming skills to design that perfect algorithm. What they truly care is whether the developed software will garner them some intrinsic value more then what they paid for, which in business parlance we know as ROI. Everything else is just details.

Consider those matters when developing your next project and you will have a win/win project in your hands with a satisfied and smiling client as a bonus.

PHP Command-line options

1 : Using a different php.ini file

The following option can be useful when you need to test various ini configurations, or you need to check if all the modules in a particular ini are loading correctly.

php –c  PATH/to/PHP.INI example.php

2 : Check to see for any syntax errors in a php file.

Need to quickly check for php syntax errors if you do not have access to an IDE, then this option can be quite helpful. Combine it with some shell code and you can easily check for syntax errors for multiple files in a directory.

php –l example.php

You can for example use the windows command line script to scan all the php files in the current directory for syntax errors.

c:\localhost>for %%X in (*.php) do php -l %%X

3 : Display php builtin and loaded modules

php –m

Combine it with php –c to debug any module loading errors for different php.ini files

php –c PATH/to/PHP.INI -m

This came in handy when I was installing php 5.3 and for some reasons the xdebug extension was not loading. With the help of the above command I was able to narrow down the problem to the following reason:

Xdebug requires Zend Engine API version 220090115.
The Zend Engine API version 220090626 which is installed, is newer.
Contact Derick Rethans at http://xdebug.org for a later 
version of Xdebug.

4 : Syntax Highlighting

The following option will display syntax highlighted text using php’s internal mechanism.

php  –s  example.php

You can then write the output to another file using a redirect.

php  –s  example.php  >  syntax.html

5 : Strip the source code of comments and whitespace.

Can be useful if you need to reduce the file size.

php –w example.php

6 : Run php code from the command line

Directly run php code from the command line without using the php start and end tags.

php -r "$foo = 'hello!'; $foo = strtoupper($foo); echo $foo;"

7 : Display information related to a internal function, class or extension

(Available as of PHP 5.1.2)
These options can be quite handy when a PHP manual is not within reach.

php --r[fcei]

Show information about a function:

php --rf usort

Example output for the above:

Function [ <internal:standard> function usort ] {
 
  - Parameters [2] {
    Parameter #0 [ <required> &$arg ]
    Parameter #1 [ <required> $cmp_function ]
  }
}

Show information about a class:

php --rc EmptyIterator

Example output for the above:

Class [ <internal:SPL> <iterateable> class EmptyIterator 
          implements Iterator, Traversable ] {
  - Constants [0] {
  }
  - Static properties [0] {
  }
  - Static methods [0] {
  }
  - Properties [0] {
  }
  - Methods [5] {
    Method [ <internal:SPL, prototype Iterator> public method rewind ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method valid ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method key ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method current ] {
    }
    Method [ <internal:SPL, prototype Iterator> public method next ] {
    }
  }
}

Show information about a extension:

php  --re json

Example output for the above:

xtension [ <persistent> extension #10 json version 1.2.1 ] {
 
  - Functions {
    Function [ <internal:json> function json_encode ] {
    }
    Function [ <internal:json> function json_decode ] {
    }
  }
}

Show configuration information for a particular extension:

php  --ri tidy

Example output for the above:

tidy
 
Tidy support => enabled
libTidy Release => 15 August 2007
Extension Version => 2.0
($Id: tidy.c,v 1.66.2.8.2.24 2007/09/20 22:25:05 nlopess Exp $)

Directive => Local Value => Master Value
tidy.default_config => no value => no value
tidy.clean_output => no value => no value

$values = array("66345:CDF", "61179:HGT", "64146:ABA",
                "68768:BNG", "68015:ZCZ", "80231:LPO",
                "64146:QWP", "68736:HHB", "86801:MNV",
                "80178:OIU", "80178:ASE", "88178:BRT",
                "801782OIU", "801378ASE", "881578BRT");

A quick solution was the following. But I’m sure that this is not the fastest, as a matter of fact it is quite slow for larger arrays.

 
<?php
 
$values = array("66345:CDF", "61179:HGT", "64146:ABA",
                "68768:BNG", "68015:ZCZ", "80231:LPO",
                "64146:QWP", "68736:HHB", "86801:MNV",
                "80178:OIU", "80178:ASE", "88178:BRT",
                "801782OIU", "801378ASE", "881578BRT");
 
 
function my_cmp($a, $b)
{
    $pieces_a = explode(":", $a);
    $pieces_b = explode(":", $b);
 
    if(!isset($pieces_a[1]) && isset($pieces_b[1])) {
        return 1;
    }
    elseif(!isset($pieces_b[1]) && isset($pieces_a[1])) {
        return -1;
    }
    elseif(!isset($pieces_a[1]) && !isset($pieces_b[1])) {
        return 0;
    }
 
    return strcasecmp($pieces_a[1], $pieces_b[1]);
}
 
usort($values, "my_cmp");
 
?>

So what will be the fastest algorithm for the same?