Yii Application Development Cookbook - Second Edition

Yii Application Development Cookbook - Second Edition - Second Edition

Overview of this book

The Yii framework is a rapidly growing PHP5 MVC framework often referred to as Rails for PHP. It has already become a solid base for many exciting web applications such as Stay.com and can be a good base for your developments, too. This book will help you to learn Yii quickly and in more depth for use in for your developments."Yii Application Development Cookbook" will show you how to use Yii efficiently. You will learn about taking shortcuts using core features, creating your own reusable code base, using test driven development, and many more topics that will give you a lot of experience in a moderate amount of time.The second edition fixes all errata found in the first edition and also features new recipes on the client side, HTTP caching, and using Composer with Yii.The chapters of the book are generally independent and since this book's goal is to enhance a practical approach to Yii development, you can start reading from the chapter you need most, be it Ajax and jQuery, Database, Active Record, and Model Tricks, or Extending Yii."Yii Application Development Cookbook" will help you to learn more about the Yii framework and application development practices in general, showing shortcuts and dangerous things you shouldn't do.With all the recipes grouped in 13 chapters, you will write your applications more efficiently using shortcuts and using Yii core functionality in a good way. The most interesting topics are; Yii application deployment, a guide to writing your own extensions, advanced error handling, debugging and logging, application security, performance tuning, and much more."Yii Application Development Cookbook" will help you to learn more about the Yii framework and application development practices in general. You will write your applications more efficiently using shortcuts and using Yii core functionality in a good way.

Yii Application Development Cookbook Second Edition

Credits

About the Author

About the Reviewers

www.PacktPub.com

Preface

Free Chapter

Under the Hood

Introduction

Using getters and setters

Using Yii events

Using import and autoloading

Using exceptions

Configuring components

Configuring widget defaults

Using Yii core collections

Working with requests

Router, Controller, and Views

Introduction

Configuring URL rules

Generating URLs by path

Using regular expressions in URL rules

Creating URL rules for static pages

Providing your own URL rules at runtime

Using a base controller

Using external actions

Displaying static pages with CViewAction

Using flash messages

Using the controller context in a view

Reusing views with partials

Using clips

Using decorators

Defining multiple layouts

Paginating and sorting data

AJAX and jQuery

Introduction

Loading a block through AJAX

Managing assets

Including resources in the page

Working with JSON

Passing configuration from PHP to JavaScript

Handling variable number of inputs

Rendering content at the client side

Working with Forms

Introduction

Writing your own validators

Uploading files

Adding CAPTCHA

Customizing CAPTCHA

Creating a custom input widget with CInputWidget

Testing Your Application

Introduction

Setting up the testing environment

Writing and running unit tests

Using fixtures

Testing the application with functional tests

Generating code coverage reports

Database, Active Record, and Model Tricks

Introduction

Getting data from a database

Defining and using multiple DB connections

Using scopes to get models for different languages

Processing model fields with AR event-like methods

Applying markdown and HTML

Highlighting code with Yii

Automating timestamps

Setting up an author automatically

Implementing single table inheritance

Using Zii Components

Creating custom grid columns

Extending Yii

Introduction

Creating model behaviors

Creating components

Creating reusable controller actions

Creating reusable controllers

Creating a widget

Creating CLI commands

Creating filters

Creating modules

Creating a custom view renderer

Making extensions distribution-ready

Error Handling, Debugging, and Logging

Introduction

Using different log routes

Analyzing the Yii error stack trace

Logging and using the context information

Implementing your own smart 404 handler

Security

Introduction

Using controller filters

Using CHtml and CHtmlPurifier to prevent XSS

Preventing SQL injections

Preventing CSRF

Using RBAC

Performance Tuning

Introduction

Following best practices

Speeding up session handling

Using cache dependencies and chains

Profiling an application with Yii

Leveraging HTTP caching

Using External Code

Introduction

Using Zend Framework from Yii

Customizing the Yii autoloader

Using Kohana inside Yii

Using PEAR inside Yii

Using Composer with Yii

Deployment

Introduction

Changing the Yii directory layout

Moving an application out of webroot

Sharing the framework directory

Moving configuration parts into separate files

Using multiple configurations to simplify the deployment

Implementing and executing cron jobs

Maintenance mode

Index

Customer Reviews

5 star

4 star

3 star

2 star

1 star

Using Yii core collections

Yii has a set of collection classes used mainly for internal purposes which are not described in the definitive guide, but are still very useful for applications:

Lists: CList, CTypedList
Maps: CMap, CAttributeCollection
Queue: CQueue
Stack: CStack

How to do it…

All collections implement SPL IteratorAggregate, Traversable, and Countable. Lists and maps also implement SPL ArrayAccess . It allows the use of collections like a standard PHP construct. The following is a snippet from the CList API:

The following is the code snippet from the CList API:

// append at the end
$list[]=$item;

// $index must be between 0 and $list->Count
$list[$index]=$item;

// remove the item at $index
unset($list[$index]);


// if the list has an item at $index
if(isset($list[$index]))

// traverse each item in the list
foreach($list as $index=>$item)

// returns the number of items in the list
$n=count($list);

CList is an integer-indexed collection. Compared to the native PHP array, it adds stricter checks, can be used in OO fashion, and allows to make a collection read-only:

$list = new CList();
$list->add('python');
$list->add('php');
$list->add('java')

if($list->contains('php'))
   $list->remove('java');

$anotherList = new CList(array('python', 'ruby'));
$list->mergeWith($anotherList);

$list->setReadOnly(true);

print_r($list->toArray());

There is another list collection named CTypedList that ensures that the list contains only items of a certain type:
```
$typedList = new CTypedList('Post');
$typedList->add(new Post());
$typedList->add(new Comment());
```
As we are trying to add a comment to the Post list, the preceding code will give you the following exception:
```
CTypedList<Post> can only hold objects of Post class.
```
CMap allows using every value, integer or not, as a key. Just like in CList, it can also be used in the native PHP style, has almost the same set of OO methods, and allows making a collection read-only:
```
$map = new CMap();
$map->add('php', array('facebook', 'wikipedia', 'wordpress', 'drupal'));
$map->add('ruby', array('basecamp', 'twitter'));
print_r($map->getKeys());
```

There is also one handy static method named CMap::mergeArray that can be used to recursively merge two associative arrays while replacing scalar values:

$apps1 = array(
    'apps' => array(
        'task tracking',
        'bug tracking',
    ),
    'is_new' => false
);

$apps2 = array(
    'apps' => array(
        'blog',
        'task tracking',
    ),
    'todo' => array(
        'buy milk',
    ),
    'is_new' => true
);

$apps = CMap::mergeArray($apps1, $apps2);
CVarDumper::dump($apps, 10, true);

The result of the preceding code is as follows:

array
(
    'apps' => array
    (
        '0' => 'task tracking'
        '1' => 'bug tracking'
        '2' => 'blog'
        '3' => 'task tracking'
    )
    'is_new' => true
    'todo' => array
    (
        '0' => 'buy milk'
    )
)

CAttributeCollection includes all of the CMap functionality and can work with data just like properties:

$col = new CAttributeCollection();

// $col->add('name','Alexander');
$col->name='Alexander';

// echo $col->itemAt('name');
echo $col->name;

CQueue and CStack implements a queue and a stack respectively. A queue works as FIFO: first in, first out, and the stack is LIFO: last in, first out. In the same way as list and map collections, these can be used in native PHP style and have OO style methods:

$queue = new CQueue();

// add some tasks
$queue->enqueue(new Task('buy milk'));
$queue->enqueue(new Task('feed a cat'));
$queue->enqueue(new Task('write yii cookbook'));

// complete a task (remove from queue and return it)
echo 'Done with '.$queue->dequeue();
echo count($queue).' items left.';
// return next item without removing it
echo 'Next one is '.$queue->peek();

foreach($queue as $task)
   print_r($task);

$garage = new CStack();

// getting some cars into the garage
$garage->push(new Car('Ferrari'));
$garage->push(new Car('Porsche'));
$garage->push(new Car('Kamaz'));
// Ferrari and Porsche can't get out
// since there is…
echo $garage->peek(); // Kamaz!

// we need to get Kamaz out first
$garage->pop();
$porsche = $garage->pop();
$porsche->drive();

Yii Application Development Cookbook - Second Edition - Second Edition

Yii Application Development Cookbook - Second Edition - Second Edition

Overview of this book

Related Content you might be interested in

Current Title:

Yii Application Development Cookbook - Second Edition - Second Edition

Using Yii core collections

How to do it…