A Newbie’s Guide.......................................................................................... 7
What This Book Is Not................................................................................................................ 7

Using Bake to Create Views....................................................................... 37
Getting the Bake Script Working In Our Localhost....................................................... 37 Bake the CRUD Views...............................................................................................................39

Cleaning Up the Views............................................................................... 42
Make the Priority Field a <select> Tag.............................................................................. 43 Change the Index View to Better Display the Completed Field............................... 43

Important Points......................................................................................... 44

INTRODUCTION
Why Cake
Ever since the boys at 37 Signals (www.37signals.com) released Ruby on Rails as an open source project, the world of web development has been moving more toward a framework-based solution for creating dynamic websites. Gone are the days of individually scripting each and every function the website will utilize. Instead, developers are using a bundled package of scripts that perform a series of functions designed speci cally for web development. Because Rails set the standard for web-based frameworks, teams of developers have been creating clones of Rails for various languages: Turbogears for Python; Symfony, PHP on Trax, Zend and many others for PHP; and Catalyst for Perl—and on and on. With so many options out there, why choose CakePHP (or, for short, Cake) for your web project?

Models, Views, and Controllers (MVC)
Cake uses the MVC structure as it compiles. What this means is that it e ectively separates typical operations into speci c areas: models for all your database interaction; views for all your output and displays; and controllers for all your commands/scripts. MVC can vary depending on the framework with which you’re working. But generally it works like this. 1. 2. 3. 4. 5. e user interacts with the interface in some way (e.g., presses a button). e controller handles the input event. e controller accesses the model to fetch any saved data or fetch data stored in the database. e view uses data handled by the controller and model to generate the user interface or any other output that must be sent to the user. e interface waits for further user interaction before the cycle begins anew.

e bene t of using MVC structures in developing websites is that repeated functions or tasks can be separated, thus allowing for quicker edits. It can even help in debugging. Say an error keeps occuring during the interaction with the database. Usually the problem will be somewhere in a model, or least likely in the controller (if you follow convention). Knowing that all database interactions occur in just one place makes addressing problems more e cient. Cake makes MVC developing a snap and actually has a straightforward folder structure that cuts down on nested folders and extra directories. When deciding between other frameworks, realize

Newbie’s Introduction to CakePHP

6

that Cake has a more e cient MVC structure than Symfony or Zend and will occupy less space on your server.

CRUD Operations
Most websites make use of CRUD operations: create, read, update, and delete. A blog, for example, will need to create posts; users will need to be able to read each post; the author will likely want the ability to edit the post in the future or update the post; and the author will also want access for deleting posts. Cake makes CRUD operations a breeze with automated CRUD functions. Instead of writing by hand each CRUD operation, Cake has pre-built classes that do it for you.

Sca olding
Getting a website o the ground is much easier with Cake’s sca olding abilities. With just one simple line of code, you can call out Cake’s pre-built sca old to render views based on the database. In other words, it gures out how some standard interface views should work with your database, and outputs the HTML forms and all without you having to write one bit of HTML. While the sca olding feature is not intended for full production views, it allows for you, the developer, to begin testing logic and functions without wasting time building views or HTML output.

Helpers
Cake comes with standard HTML, Ajax, and Javascript helpers that make creating views much easier. Your HTML output will be greatly facilitated by coherent strings of helper code that render the markup for you. And getting Ajax to work, while a little tricky at rst, is much easier and far more e cient than building those nasty Ajax scripts yourself. What’s more, you can download other helpers written by fellow Cake developers to boost the strength of the framework, or even write your own to cut down on repetitive or clumsy markup.

Large Community
Should you need help down the road, a massive online community exists to help out. Not only can you appeal to expert advice from Cake gurus on forums and message boards, but even more PHP experts can help you with learning the code. In reality, the PHP community is the largest programming group on the web, so if you need a quick workaround for a problem in Cake, someone somewhere will have some help for you, usually within minutes. Code samples are a must for anyone getting involved in web development. PHP dominates this eld, and Cake has a growing repository of code samples as well. When considering going with another framework, this fact just may tip the scales in favor of Cake if you are wanting to piggyback on someone else’s work.

Newbie’s Introduction to CakePHP

7

Much More
As you can see, Cake aims to simplify the development process through competing features that have signi cant advantages when learning to develop web so ware or taking on web development tasks. Even more features could be talked about, but since this is a newbie’s guide, we’ll save that for more advanced conversations. What is important to note is that Cake is so far the most popular PHP web framework, and it has a great start on providing needed features for PHP developers that you can’t pass up.

A Newbie’s Guide
is guide is for true newbies to PHP and Cake. If you’re already familiar with Ruby on Rails or another web framework then this guide may be a little redundant for you. But if you don’t know what a “has-and-belongs-to-many” relationship is or how to parse an array, then this just may be where you want to start when getting into Cake. A er poring over the online documentation, I realized there wasn’t much by way of an introduction to Cake. Most of the available resources require some sort of prior knowledge of web development to get a grasp on how to install and work in Cake. If you’re like me, you probably just want a handful of tutorials with code samples from square one that can get you up and running quickly and lead you in the right direction for more advanced techniques. Furthermore, when asking a question on forums or chat rooms, many newbies get little help from the experts. Simple questions can get a response like, “Well, just read the online manual and API.” Sometimes we newbies need a very simple approach to the so ware, and this guide will do just that. We’ll start with installing Cake on a server and a localhost, what it all means, and provide some detailed code samples and visual snapshots to walk you through. By the end of the book, you ought to have a solid-enough foundation to give other advanced features a try on your own.

What This Book Is Not
Now, I recognize that there are myriad scenarios for installing PHP, MySQL, CakePHP, Apache, and more. I won’t explore every possible setup. Rather, this book will walk through one method for working with Cake with the newbie in mind. So my aim is to go about the most simple method for working with web servers and so ware. If you are searching for a unique way for working in Cake, you ought to consult the web in general, the Google group, or other experts on the Cake chatroom on IRC (all this can be found by going to www.cakephp.org). If, however, you’re stupi ed over getting Cake, PHP, MySQL, Apache, and other web technologies to work, then this book will get you started o well.

Newbie’s Introduction to CakePHP

8

INSTALLING CAKE
Localhost First, Remote Last
e best way to setup your development environment is to con gure a localhost server on your computer. Let me explain what that means. When you access a website, you’re sending and requesting information from another computer through an internet connection. at server can communicate and process the information in a plethora of possible con gurations. For example, when you buy a computer, you have the option of getting a Mac or Windows-based machine. Or, if you so wish, you could run Linux, Unix, or even DOS. All these possibilities mean that for you, the user, your experience will depend on which operating system you choose. But let’s say you want to print a document. Well, regardless of the OS, or how that OS prints something, once the document is printed, it doesn’t really matter what con guration the computer had, it’s all the same to the reader of the document. e internet is a lot like this example. e computer/server at the other end that will be processing the requests and creating output could run just about anything. But the nal output will be a web page of some sort, or some kind of web output. For you as the developer, the con guration will matter a great deal. In fact, it will a ect everything that you do to create and serve a web site. When you set up a localhost, you’re actually setting up a server on your own computer. You’ll re up a web browser like Firefox or Safari and type in something like “http://localhost” to access the server like the user would if the web site were live. In e ect, you’re tricking the computer into thinking that it’s talking to a web server when really it’s talking to itself. As long as your con gurations on your localhost are the same as the con gurations of the remote web server where the site will be hosted, you can develop on your own computer. Once the site is running well, you’ll move the entire contents of your root directory or application to the server, and you’re done. If you’ve done it right, the site should run all the same on the remote server.

Why Doing It All Remotely Is Bad
Should you circumvent the localhost setup, you’ll be forced into developing everything remotely. at’s ne, I suppose, if the following things don’t bother you: • Running a continuous FTP session. • Uploading every time you want to test the slightest alteration to your code. • Timeouts due to your internet connection occuring during program executions. • Creating alternate names to test in environments of which no one is aware. • Users accidentally stumbling on your half-baked programs. • Eating into your own bandwidth (which for some hosting plans may be tight as it is).

Newbie’s Introduction to CakePHP

9

Localhost Setup
Whatever OS you’re running on your computer, installing a localhost environment is easy. If running on a Mac, I recommend installing Living-E’s MAMP. If on a Windows-based PC, install XAMPP. Normally, creating a localhost setup will require installing various server programs via a command line interface that takes a good understanding of PHP, MySQL, Apache, ProFTPd, and other server technologies. What MAMP and XAMPP do is simplify these complex server setups so that essentially you run an installer program and the setup is complete.

Setting Up on a Mac
Mac OS X already comes with a localhost setup built in. But if you want to run MySQL and upgrade PHP to version 5.0 or higher, you’ll need to install each element manually, which can be a little tedious. Running MAMP will likely save you a lot of time. Here’s how to do it. Download the so ware. Go to http://www.mamp.info and locate on the home page the MAMP download link. It will ask you if you want MAMP Pro, and if you do, go ahead and pay the $49 to download it. Otherwise, download the latest free version of MAMP. Open the disk image and install the MAMP folder. is step is simple enough. It will ask you to drop a folder into the Applications folder. is is necessary for the localhost setup to work properly. Make sure you do not use any subfolders or rename the MAMP folder to anything else. If you dislike having to do this, you may want to consider more elaborate localhost setup methods. Run the MAMP application program. At any time you can manage your localhost setup by running the application Applications > MAMP > MAMP. is main screen looks like this:

Newbie’s Introduction to CakePHP

10

is program, when you click “Start Servers,” will maintain the localhost environment. You now can begin executing PHP code, but you have to know where to access the localhost on your hard drive. Con gure the localhost root folder. By default, any le contained in the Applications > MAMP > htdocs folder can be accessed in the localhost environment. is isn’t too bad, altogether, but I personally prefer having my web sites outside my Applications folder. Changing this setting is as simple as going into the preferences area of the MAMP application. Click on “Preferences…” to bring up the preferences area. Click the “Apache” tab, and you’ll nd a eld called “Document Root.” It should read “/applications/mamp/htdocs” or something like that. Click “Select…” to change the document root to something else. In this case, I’m going to select the ~/Sites/ folder (if my Mac OS X user name is “dave,” then the path will look like /Users/dave/ Sites). Now, from here on out, any folder or le places in the Sites folder will be executed by the MAMP localhost setup and not Mac OS X’s default web sharing. Change the localhost ports. Now click on the “Ports” tab, still in the Preferences area. It lists the Apache port and the MySQL port. e values in these elds are set to 8888 and 8889, respectively, by default. To better mimmick a typical remote web server, these should be changed. In the Apache port eld, type “80” and in the MySQL port eld, type “3306.” (You can also click the button “Set to default Apache and MySQL ports”.) Because these ports are con gured this way, you can now open Safari and type “http://localhost” instead of “http://localhost:8888” whenever you want to execute scripts and les. Also, when con guring programs to work with MySQL, you can simply enter “localhost” in the server setting instead of “localhost:8889.” Make the localhost easier to manage. It can’t get much easier than this to get a localhost environment running on a Mac. But one aw with the MAMP application is that it must be running for the localhost environment to be running. So if you quit out of MAMP, you will no longer be able to run PHP code via the localhost. Fortunately, Living-E provides a Dashboard widget that does exactly what the MAMP app does to keep the localhost active. Simply launch the “Mamp Control.wdgt” le and click “Start Servers” to make the localhost active. It will now run in the background through Dashboard. “Hello world!” Let’s make a “Hello world!” script to make sure our localhost is working right. Go to the root folder (again, mine is located in my “Sites” folder) and create a new folder called “hello.” In that folder, create a plain-text le called “index.php.” In index.php, paste the following code:
1 2 3 <? echo “Hello world!”; ?>

Now, open up your web browser and type “http://localhost/hello”. You should get “Hello world!” to display on the screen. You are ready to begin an installation of CakePHP.

Newbie’s Introduction to CakePHP

11

Setting Up on a PC Running Windows
Windows XP Pro has Microso ’s web server built into it, known as “Internet Information Server” (IIS). To install IIS is pretty easy to do. However, most PHP/MySQL scenarios are more easily handled in a bundled localhost installer available from Apache Friends (www.apachefriends.org) called XAMPP. Here are the steps to take when installing and con guring XAMPP on your PC. Download the so ware. XAMPP can be downloaded from the Apache Friends website. As of the printing of this book, a direct link is right here: http://www.apachefriends.org/en/xampp-windows.html You can download an installer application, a Zip le, or a self-extracting 7-ZIP archive. e easiest option is to just run the installer application. So scroll down to the download area of the page and click “Installer.” e download should immediately commence. Run the installer program. e program will walk you through installing XAMPP. It will ask for a destination folder for XAMPP, and the default location is at c:\xampp. I recommend sticking to this con guration since you will likely want XAMPP to be able to access any area of your C-drive. Click “Next,” and on the next screen leave the “Service Section” checkboxes blank. To wrap it all up, click the “Install” button at the end. It will extract all the necessary les and leave you with a convenient localhost environment in the c:\xampp folder.

Open the XAMPP Control Panel. A er installation is complete, you’ll be taken to the XAMPP Control Panel. is panel is accessible in the future by clicking on the shorcut icon on the desktop, or by going to Start > Apache Friends > XAMPP > XAMPP Control Panel.

Newbie’s Introduction to CakePHP

12

e screen looks something like this:

Clicking the start buttons starts those important web server services like Apache, MySQL, and more. Start up Apache and MySQL using the start buttons and re up your web browser. In the URL eld, type “http://localhost”. You’ll be taken to the XAMPP welcome screen.

Newbie’s Introduction to CakePHP

13

Make the localhost more secure. Unfortunately XAMPP doesn’t come pre-installed with a more secure localhost environment. In some ways this may be a good thing, but for right now, the last thing you want is to compromise your network or your computer. On the le side of the XAMPP startup web page is a link to “Security.” Go ahead and click that, bringing up the security information page. Most items, if not all, will be marked “unsecure.” Let’s make those all light up green. A link below the main table called “http://localhost/security/xamppsecurity.php” takes you to some elds that will allow you to secure the localhost. Change the MySQL root password and click “Password changing”. Below the MySQL root password elds is another set of elds to protect the XAMPP directory (.htaccess). Put in a user name and password there. For both, make sure you do not save the passwords in a plain text le. From here on out, you will be asked to log in to access the XAMPP control pages. Be sure not to lose your user names and passwords! (I really shouldn’t have to say that, but you never know.) Restart Apache and MySQL to propogate the settings you’ve created. “Hello world!” Let’s make a “Hello world!” script to make sure our localhost is working right. Go to the root folder (located now at c:\xampp\htdocs) and create a new folder called “hello.” In that folder, create a plain-text le called “index.php.” In index.php, paste the following code:
1 2 3 <? echo “Hello world!”; ?>

Now, open up your web browser and type “http://localhost/hello”. You should get “Hello world!” to display on the screen. You are ready to begin an installation of CakePHP.

REMINDER
From here on out whenever I’m referring to your “root” folder, it’s going to be where the locahost can access scripts and les. For Mac users who followed this tutorial, this folder will be the user’s “Sites” folder. For Windows users running XAMPP, this folder is the “htdocs” folder in the c:\xampp folder.

Running MySQL
MySQL is an open source database program that runs well on web servers. In your localhost setups MySQL is already installed, but we have to now access the program to begin creating databases for Cake to use. First, a note on database management.

A Quick Overview of Database Management
Many web sites run on plain les without any use of databases or dynamic scripting. Databases can save the day because they can hold data for easy retrieval on your server. All those accounts people create to use big-name sites like Ebay or Amazon are stored in some kind of database, not

Newbie’s Introduction to CakePHP

14

in plain text les. While this can be extremely useful, all the talking back and forth between your scripts and the database can result in lines and lines of query strings and code. SQL is a light-weight language (it stands for “structured query language”) that makes data retrieval much less complicated than other high-end database systems. ere are extensions that add more functionality to SQL, depending on the aim of the extension. Actually, SQL is only a language and nothing else—it isn’t an application itself but it can be applied to any database program out there. SQL extensions sure make life a lot easier for developers in that they simplify the setup, connecting, scripting, and maintaining of SQL database servers and tables. ANSI, IBM, Microso , and Oracle all extend SQL in di erent ways. MySQL is just an open source extension that is designed with the web in mind. I’ve chosen MySQL for use in this book because it is far more common among web hosting providers and PHP programmers than the others. It’s also got a lot of community support out there, so if you are really itching to get a deeper look into MySQL, it’s only a couple clicks away. As you are a newbie to CakePHP, I’m going to assume that you’re a newbie to MySQL as well.

How It’s Organized
Whether you’re using one MySQL application or another, MySQL has the same overall structure. Here we’ll go over the di erent parts of MySQL and how they relate to one another to provide you with e cient database management tools. Databases (or, sometimes called Schemas). MySQL can store multiple databases. In theory, a database is going to be dedicated to one web site or web application a piece. So if I were to create a shopping cart application, I might call my database “cart.” is database would connect to my shopping cart scripts alone and store all the necessary information for that one application to work. If I had another email application on my site, I might put all that necessary information into another database called “email.” e more individual my applications are (e.g., “cart” and “email” have little to do with each other as users interact with them on the site), the more ideal it is to keep these applications to their own databases. Rarely, you may want your databases to fetch data from a separate database. But most of the time, you’ll want to have your scripts fetch data from just one database. Tables. Each database contains one or more tables. A table is a set of records grouped together. e necessary elds and cells are organized by the table, so this is usually the rst step in building your database. When creating a table, MySQL asks you how many elds (columns) you’ll want to create and how to name them. Going back to my shopping cart example, I’ll probably want to have a table called “orders.” In this table, each entry would represent one order. So, I’ll ask myself “What does each order have in common?” A person who placed the order, an item ordered, an amount paid, and so forth. ese elements make up the elds of the database table and are lled up with data when a record is created. Relational tables. Tables can relate to one another in complex ways. In a shopping cart program, not only will users store information regarding their orders, but they may select items from a catalog to buy. I’d then build that catalog as a table in the “cart” database and call it “items.” Each

Newbie’s Introduction to CakePHP

15

record in the items table would be one product with a price, shipping cost, etc. en the “orders” table would have a space for linking up with the “items” table, because each order would be for at least one item. We’ll go into detail about relational tables and databases; for now, know that tables can be linked to one another to simplify data retrieval and organization. Records and elds. As explained in the tables examples, each table contains one or more records (rows) of data. It’s best to build your tables with records in mind. If, for example, the table is mainly built for “user accounts” then each record ought to represent one user account. If the scope of your database gets more complicated than this, then it’s best to build relational tables and link them to one another. is cuts down on scripting as well as load time. Fields are the areas each record shares that are speci ed by the table. An array of available eld options exist, depending on the type of eld (a name versus a date or checkbox) and how much data the eld will hold (12 characters versus 200). Each eld will always be assigned a type, length, and default value (which can be blank, if you want).

PHPMyAdmin
e most powerful web-based tool for setting up and running MySQL is called PHPMyAdmin, another open source application that comes installed with MAMP and XAMPP. e startup screens for both localhost environments contain a link to PHPMyAdmin. is is the quickest way to begin working in MySQL, since we’ve already installed a localhost that has the program precon gured and ready to go. A great many developers prefer PHPMyAdmin over other desktopbased MySQL applications because it’s web-based and free, and quite honestly, a great application. I prefer desktop-based applications because of their speed and I can avoid screen refreshing which PHPMyAdmin is locked into for being a web application.

Other MySQL Applications
If you’d like to use a desktop application to manage your databases, here are a couple great sources to try out. ey will likely require an extra level of con guration to get them working with your localhost environment. I’ll list them below then explain some of the necessary settings to get them working right. CocoaMySQL. On the Mac, probably the simplest freeware application for running MySQL is CocoaMySQL. (It’s available by going to http://cocoamysql.sourceforge.net.) MySQL Query Browser. On both Mac and PC, MySQL Query Browser is a reliable and easy f reeware application that lets you navigate MySQL through a graphical interface (http://dev.mysql.com/downloads/gui-tools). HeidiSQL. Much like CocoaMySQL on the Mac, except built for Windows. e layout is, in some ways, much easier to navigate than MySQL Query Browser and will require a less MySQL prowess to get started. It, too, is open source, so giving it a try can’t hurt (www.heidisql.com).

Newbie’s Introduction to CakePHP

16

Typical Settings
No matter what application you decide to use, each one will need some parameters before it can connect to MySQL. Here are the common ones that get you connected. • Host • User • Password • Socket • Port Host. is will almost always be just “localhost,” even when you’re setting up a script to run on your remote server. If you are trying to access a remote database, it might be the domain name of the site, but you’ll need to have the details provided from the web hosting provider. With the con gurations outlined above, simply enter “localhost.” Should this not work, just identify the IP address of your computer, which is usually defaulted to “127.0.0.1”. User and Password. MySQL supports multiple users and groups for administering and maintaining databases. ese can be added or changed once you’ve logged into your application and access the necessary areas to add or change an account. In our example, this will be both “root” for username and password, unless you entered something di erent instead. Sometimes web hosts will set up shared hosting accounts for you; in these cases you may need to add a pre x to the username, like “cake_”. Socket. When MySQL is running, the connecting point for the application and PHP is called the “socket.” e default path for this is /var/mysql/mysql.sock but with our quick and easy localhost setup con gurations, this will be a dead end. If you know that the MySQL socket is stored in its default location (like on most hosting setups) then you can leave this setting blank. On the localhost, we’ll have to specify the path. On the PC, the defaults connect correctly if you followed the tutorial. On a Mac, here are the path strings, if necessary. On MAMP: /applications/mamp/tmp/mysql/mysql.sock On XAMPP: /applications/xampp/xampp les/var/mysql/mysql.sock Port. e default port for MySQL is 3306. Enter this only if the application asks you, or if you somehow altered the port number to something else.

REMINDER
When referring to MySQL, I’ll assume you know how to connect to your databases, create, delete, and modify them as well. So now is a good time to try and practice creating a database, creating a table, and adding some records to that table.

Newbie’s Introduction to CakePHP

17

Running CakePHP
e localhost is now ready to run Cake. Download the latest stable release of Cake from cakephp.org. (Right now, the most current stable release is Cake 1.1. Because version 1.2 is set to o cially take over, and it does have some signi cant improvements, we’ll use 1.2 in this book.) When you’ve downloaded and extracted the Cake release le, you’ll end up with a folder called “cake_1.2.0.1111” or something like that. Inside this folder contains everything you need to run Cake:
app/ cake/ docs/ index.php vendors/

O the Ground
Now, let’s get o the ground with this Cake stu . It’s time to actually turn the switch on. Rename the folder. Name the “cake_1.2.0.1111” folder to “cake.” Move the cake folder. Place the “cake” folder into your localhost root. Launch Cake. Open your web browser and type “http://localhost/cake” in your URL eld. You should get the following screen:

Newbie’s Introduction to CakePHP

18

Typical problems. Now, you may, at this point, have encountered a couple typical problems with the installation. Permissions error. ere may not be the necessary le permissions in place. If this error occurs, you may have only seen a blank screen or a “403” error screen. To x this, open the “cake” folder with “Get Info” on a Mac, or right-click and select “Properties” on a PC. You’ll need to make sure that the “System” user can read/execute the folder and all its contents. If you’re already familiar with the command-line, open a shell, browse to the folder, and give it a “chmod” value of 755. Refresh the “cake” URL and if you see the screenshot above, the problem is xed. Apache AllowOverride error. is error occurs when you see the content but it doesn’t appear like the screenshot image you see, i.e., no color, no styles, just black, default text on white. If you continue with the rest of the tutorials here, you’ll be able to see Cake running, but some things will bug in and out on you, especially the sca olding and the styles. is x is a little more complicated, but not hard. You’ll need to nd the “httpd.conf ” le in your localhost setup. It’s usually stored in a folder named “conf,” “bin,” “lib,” or “var.” e httpd.conf le can be edited by any plain-text editor. Search out a chunk of code that looks something like this in the httpd.conf le:
1 2 3 4 <Directory /> Options Indexes FollowSymLinks AllowOverride None </Directory>

Change line 3 to:
3 AllowOverride All

en open the control panel for your localhost (either the MAMP dashboard widget or the XAMPP control panel). Restart Apache and try again to refresh the Cake program in your web browser. e problem is xed if you see “life” brought back into the startup screen.

Setup Routines
Every time you install a Cake application on your localhost, you’ll follow these routine procedures. 1. Prepare the “tmp” folder. 2. Set the “CAKE_SESSION_STRING” global variable in app > con g > core.php. 3. Enter MySQL database connection settings. 4. Design your database schema. Prepare the “tmp” folder. Inside the root > cake > app folder is a folder named “tmp.” Cake needs to be able to tinker with this folder to operate, so this folder’s permissions will be di erent than

Newbie’s Introduction to CakePHP

19

the others. If you’ve used the command line before, this process is fairly simple. If not, now’s the time to begin. Command line on the Mac. Mac OS X comes with a built-in command line application located in the Applications > Utilities folder. When Mac OS X was rst built, they did it on top of Unix, making the command line actually a part of the operating system. Mac users will nd a basic knowledge of Unix commands extremely useful for high-end processes. Launch the Terminal application from the Utilities folder, and you’re there. You type a command, hit return, and that’s pretty much it. Command line on Windows. You can launch the Start > Accessories > Command Prompt to access the command line, but this actually is running MS-DOS. For web services, we’ll need to be able to run Unix commands. is will require an additional installation of command line tools. Microso created its Powershell program to boost the command line functionality of Command Prompt. However, Powershell won’t behave like most web developers desire; it will be missing some common commands like ls, chmod, and ln. If you still would like to run Powershell, it’s available at: http://www.microso .com/windowsserver2003/technologies/management/powershell/default.mspx. Two useful applications can provide commands you will use frequently when running Cake, or any ot he r web s e r v i c e for t hat matte r : Cy g w i n ( w w w. c y g w in . com ) and Mi n G W (www.mingw.org). Both come with installer applications that are fairly easy to run. (I prefer MinGW running with MSYS, both available through MinGW’s web site.) Setting permissions in the command line. Now, to set the necessary permissions for the tmp folder, launch your preferred command line program. You will need to point to the path of the tmp folder. On the Mac, remember, this is set to the user’s Sites folder. On the PC, it’s the htdocs folder in the c:\xampp folder. (Mac) (PC)
$ cd ~/Sites/cake/app

$

cd /c/xampp/htdocs/cake/app

Use the “chmod” command to set the permissions of the tmp folder:
$ chmod 777 -R tmp

And you’re done. The tmp folder is now ready for Cake. Set the CAKE_SESSION_STRING in the core.php file. For a web application to communicate with a user’s unique set of desktop programs, requests are sent back and forth. The server receives requests and processes them, then provides output back to the user. Frankly, these requests can get interrupted (something you’ve likely experienced when your browser has a “timeout”) or the server can get confused about which request is coming from whom. An essential attribute of all web applications is its use of sessions.

Newbie’s Introduction to CakePHP

20

When a session is initialized, the server groups a set of requests together using a session id, a database, or a cookie. Whatever the method, the idea behind the session is that the server can maintain a pseudoconnection with the user, even though the communication could get interrupted along the way. You’ve run into this when you’ve logged into your web-based email account or some similar web service. The site application knows that you’re logged in and maintains that status until you log out or a cetain length of inactivity transpires. Luckily for us, Cake makes session handling easy. But we do need to make sure that its session string is secure (we wouldn’t want users out there to toy with the session handling in an effort to break into our applications). To do this, open the app > config > core.php file and locate line 97, or thereabouts. You’ll find a line that looks like this:
97 define('CAKE_SESSION_STRING', 'DYhG93b0qyJfIxfs2guVoUubWwvniR2G0FgaC9mi');

is is a PHP de nition string. Essentially, this line is saying in PHP to de ne a variable called “CAKE_SESSION_STRING” to have the value “ DYhG93b0qyJfIxfs2guVoUubWwvniR2G0FgaC9mi.” Because that funky bit of characters comes with Cake, everyone who uses Cake has the same session string. Let’s change the second portion, the character string, to something unique. Web sites like www.grc.com/passwords.htm generate alpha-numeric passwords or random strings for better security. Go ahead and grab an encrypted alpha-numeric string, about 40 characters in length, and paste it here. I ended up with:
97 define('CAKE_SESSION_STRING', 'mEayuDrXBhZkdiEJgFzPXvbcBrmKo9CdVGtKyPBr');

Now when Cake manages sessions for this application, it will have a more secure string to store. Setting a random string of alpha-numeric characters for the CAKE_SESSION_STRING de nition is a good idea and worth your typical Cake application setup routine. Enter MySQL database connection settings. Cake needs to know where you databases are located so it can fetch from and insert data into the application’s programs. is is done by editing the app > con g > database.php.default le. You’ll need to rename the le to “database.php” (remove the “.default” from the end) and edit it in your plain-text editor of your choice.

In this tutorial, we’re creating a generic Cake application. In the future, we’ll name the database based on the application we’re building, but for now, we’ll just create a database called “cake.” e

Newbie’s Introduction to CakePHP

22

settings above will tell Cake how to connect with this database, but we aren’t done yet.… We need to create the database! Design your database schema. It’s best to know how the database design will work from the outset. So take some time to get at least a moderate idea of the program you’re building rst, and then build some tables and elds to t that design. is application is super boring, with nothing really in the database. We just want to connect Cake to the database. Fire up the MySQL application of your choice (I’m using CocoaMySQL) and connect to MySQL. Create a database called “cake.” Now that a database actually exists for Cake to connect with, you can go to http://localhost/cake in your browser and it will display a new screen:

Cake is now installed and working correctly. It’s time to dive in and start building web apps!

Newbie’s Introduction to CakePHP

23

YOUR FIRST CAKE APP
Before we begin building your rst Cake app, let’s take a moment to discuss important editing options.

Plain Text Editors and Other Applications
When developing for the web, all the scripts and les are rendered in plain text. It’s important that you nd a text editor or HTML editing program that ts your work ow style. e available choices may change dramatically from year to year, as many open source projects come and go. Below are some recommendations that will certainly make developing in Cake easier to manage.

Plain Text Editors
Coda. Panic’s new web program Coda (www.panic.com/coda, $79) is my personal favorite because of how it consolidates almost all aspects of web development into one window.

On the le is a le browser and FTP uploader. A simple click will open any le (local or remote) you see there. In the main text area is where all the code is displayed. Coda supports multiple languages and can colorize your code to help you with your syntax.

Newbie’s Introduction to CakePHP

24

It also has a built-in CSS editor, should you need a nice graphical approach to building your stylesheets. And, the terminal is also built into the window, making any command line scripting a breeze. Coda has even more features that will certainly appeal to any Cake developer; it’s worth the free demo. Disadvantages. e only disadvantage is that it’s only available for the Mac. It doesn’t have a MySQL editor; future releases just may come with that built in, like the terminal shell. TextMate. TextMate (www.macromates.com, €39) is a lot like Coda, with a le browser and multiple tabs for editing many les at once. One sweet feature is its use of code bundles. Instead of typing monotonous code strings, TextMate come with code bundles that allow you to essentially start a string and it lls in the rest for you. is can cut down on editing time dramatically. Also, you can customize your own code bundles to better match your routines. It, too, comes with a free demo you can download. Disadvantages. Another Mac only program, but well worth its functionality. e price tag, for some, may be a bit steep for what you’re getting out of it. In all, TextMate is a good application to try out. Adobe Dreamweaver. Dreamweaver has been a standard HTML application for years (www.adobe.com/products/dreamweaver, $399) and may well continue to be so for more to come. Most of its features are related to web design, not necessarily web development. So, when rendering HTML/CSS and maintaining a web site comprised of static HTML pages, Dreamweaver can be a powerful piece of so ware. It can support customized templates that you apply to static pages, making editing mass web site assets easier. However, should you want to incorporate PHP code, it is pretty well generic, and you will likely move away from it to a better code editor anyway. e steep price tag is as high as it gets, but well worth it if you’ve bought the Creative Suite bundle and can combine Dreamweaver with the power of Photoshop and Illustrator (absolute essentials in the graphic design world). Nvu (www.nvu.com, free). is open source program is meant to mimmick Dreamweaver and similar WYSIWYG HTML editors. It lacks some of the powerful Ajax features the newest Dreamweaver has, but it well worth the download. For web development, you may want this for your HTML or CSS creation, but may nd it a little clumsy for PHP code editing. Eclipse. When it comes to programming in general, Eclipse is an incredibly powerful program (www.eclipse.org, free). e developers community for Eclipse is extensive, making updates to the so ware e cient and frequent, a bonus for you in the long run. Eclipse comes with di erent language IDEs, simplifying the editing process by pasting and completing code syntax and strings. Its preview, le browsing, and server setups are also incredibly advantageous, especially if you intend to develop with several other people. Perhaps what sets Eclipse apart from the rest of this list is its CVS and Subversion implementation, making collaboration a cinch. If you have no doubt but that your applications will be developed via the open source community or in a company using some code check-in/check-out system like Subversion, then you must take a look at Eclipse at some point.

REMINDER
It doesn’t matter which applications you use to create your Cake applications. You will need to make sure, though, that you are saving your les in a plain-text format and not another word processing or image format (e.g., a Word .doc le). I’ll assume you’ve picked out a good selection of applications that do all this for you without having to specify a le format, but I will point out which le extensions to use.

A To-Do List Application
For your rst Cake application, let’s build a to-do list program. First step: rename the previous application folder from “cake” to “todo.” (Whenever we launch the program, just type in http://localhost/todo.)

Create the Database Schema
Our database is the rst thing to work with. Remember, we built a database in MySQL already called “cake.” Go ahead and rename this if you want, or leave it the same; in either case, in the app > con g > database.php le, it’s already pointing to the “cake” database and must be changed in the event that you do decide to rename the database. e database is empty, so we need to create some tables rst. is application is simple enough: it’s just a list of to-do items that are either completed or not. Let’s name the table, then, “items.” Next, create the elds. In our to-do list, we’ll have the name of the item, some detail of what needs to be done, whether or not the item is completed, a due date, and a priority. e name eld will be the SQL type “varchar” because it will contain only one string of text, not multiple lines. e detail, however, could be a whole paragraph, so we’ll assign this eld the type “text.” e completed eld will be either a true or false (in SQL/PHP, we’ll use a 1 for true and 0 for false), so make this

Newbie’s Introduction to CakePHP

26

eld a “tinyint” type. e due date will contain the date and time of the item, and MySQL conveniently has one of those as a type, so this one will be simply of the type “datetime.” When naming this eld, you can’t have spaces, so put an underscore between the two words (e.g., “due_date”). Last, priority is just an integer between 1 and 9; make this “smallint.” As you create the elds and specify their types, you will be given the option of specifying a eld length. In the case of “varchar,” “tinyint,” and “smallint” types, we’ll need to tell MySQL how long the chunk of data to be stored should be. If the user enters more characters than we specify here, MySQL will simply trim o the excess and store up to the eld’s limit. e maximum for “varchar” is 255, which is pretty he y. Just to be sure, though, let’s plop that value into the name’s eld length. e true/false “tinyint” should be just one character, so make the completed eld length 1. For the priority eld, set this length to 1 as well. e “id” eld. As a standard procedure, you ought to have what’s called a primary key eld. is eld makes queries faster and helps MySQL to connect records in the database faster. By making an “id” eld, each to-do list item stored in the table will have a unique identi er. Cake and MySQL can parse through this more quickly, and Cake is more able to handle the data with a unique id. Almost without exception, every table should have an “id” eld, of the type “integer,” and a eld length of at least 11. is eld will need to be set as the “primary key” with “auto_increment” added to it. Now, no matter how many items are stored in the database, no two records will have the same id value, a safe precaution to protect against duplication of data and confusing Cake. (Make sure before creating the primary key that you move “id” to the top position—it won’t let you change the eld order once the primary key is assigned.) Your database schema should look something like this:

Create the Items Controller
In the app > controllers folder, create a new le for the “items” table in the database. Controllers, by default, link up to the table a er which they are named. In this case, we have created an “items” table, so the convention in Cake is to name the controller le a er this table, using an underscore and the extension “controller.php.” So name this new le “items_controller.php” and place it in the controllers folder. Next, in the items_controller le, paste the following code:

Let me explain what’s happening on each line. One line 1, we are initiating a PHP le. Important: depending on your localhost or remote host setup, this line may need to be changed. I’m using, in this example, a type of shorthand for PHP; just the less-than symbol and the question mark. In many setups, this shorthand won’t y, and you’ll need to use <?php instead. Semantically, shorthand makes your code cleaner and easier to read, so I’ll stick with it, but you will want to double-check the examples if you have set up your localhost di erently than the earlier tutorial in the chapter “Installing Cake.” Line 2 is necessary for Cake to run the controller. Cake is already starting some of its own PHP code in what it calls the controller. Next, it moves down the tree to the application’s own controller, or “AppController.” And lastly, it scans the controllers folder for individual controllers. All the way down, we need to tell Cake if we’ve inserted our own AppController or individual controller le, and we do this by starting a class and extending the previous level of controller. In this case, we created the “ItemsController” class, and it extends out from the “AppController.” e braces hold everything, code-wise, that is included in this individual controller. Line 3 is just good practice. ere are a plethora of setup scenarios with which Cake can be installed. By specifying a name for the controller, we bypass potential hazards of Cake not knowiing what’s what. Technically, you can leave out this line, but it doesn’t hurt to habitually include it, and avoid possible bugs. In line 4, we’ve called out one of Cake’s built-in features: the sca old. In any controller, you can include this line and Cake will build its own set of HTML forms and tables around what it nds in the database table. In a second, you’ll see how helpful this one little string of code can be. Lines 5 and 6 close out the controller, following PHP’s syntax structure.

Create the Items Model
Now, the controller can only do so much. It needs now to be able to connect to the database and lter through the table data we’ve already set up. Cake separates these functions away from the controller through the use of “models.” In every case, the model is the mechanism by which we access the database, check for database errors, and employ any lters to clean up our data. In the app > models folder, create a new le called “item.php.” Again, this le naming scheme is a convention used in Cake to make accessing the database more simple. Should you name it something else, you’d need to add more strings of code in your controller le and in this le to tell

Newbie’s Introduction to CakePHP

28

Cake where to go. By default, it will search the models folder for a singular term of the database table, in this case, an “item” model. Paste the following code in the “item.php” le.
1 2 3 4 5 } ?> <? class Item extends AppModel { var $name = ‘Item’;

ings are looking similar to the items_controller we already created. Line 2 follows the naming convention in Cake, telling Cake that this model extends the AppModel and is called “Item.” We’ve also included the naming string for good measure on line 3. As there is nothing else to do with the data, we’re done, so we close it out with lines 4 and 5.

Launch Your App
e URL structure of Cake follows a simple pattern: application/controller/action/parameters. We’ll examine this ow later on. For right now, to re up the items controller, type http://localhost/todo/items in your web browser. anks to Cake, virtually everything is complete! You’ll see a screen with all the database elds conveniently rendered, a list view in HTML all designed and populated, and the editing, deleting, adding actions all taken care of. Because we told Cake to build the sca old on line 4 in our items_controller, it was able to scan the database and create all the typical views that follow CRUD operations (see “CRUD Operations” on page 3).

Naming Conventions
By now you can see that much of what Cake does relies on naming conventions. For example, you didn’t need to create a speci c connection script that told Cake to connect to the “items” table in the database when the items controller is called. Cake just intuitively knew that the items table was where to go to fetch the data. Well—not exactly! Actually, Cake knew to go there because we followed its naming convention. It’s important to understand how naming conventions work in Cake, at this point, and to follow those naming conventions when we build our Cake apps.

Newbie’s Introduction to CakePHP

29

Controllers
When you create a controller, it’s important to keep the name of the controller le consistent with the naming convention in Cake. e name will always be the plural form of a record in the database table. Since we are using “items” and each record in the table represents one item, the name of the controller le will follow the name of the table. You will recall when we created the le “items_controller.php,” I explained why we named it that way. Well, whenever you create a controller le, almost without exception you should follow this convention: Plural word of the database table followed by an underscore and the word “controller” with the PHP extension (.php). As long as this is the case, Cake will automatically link the controller up with the model, view, and database records.

Models
Models are like controllers in their convention—they must follow a speci c pattern for Cake to recognize that they’re linked up with other controllers and views—but the name is di erent. e model represents the record in the database table. Each record is singular, so the model name follows this pattern. In our example, each record represent one “item,” so our model le is named “item.php.” When naming your model les, follow this convention: Singular form of the database table title followed by the PHP extension (.php). Cake is pretty good at guring out irregular pluralities like “university” and “universities” but sometimes it may not put the two together. We’ll talk about how to x this later. For now, just stick with good names that aren’t too convoluted, and Cake will bridge the les together as it runs.

Views
e views are tied to speci c functions in your controller le. erefore, they are named a er the function itself. If I make a function called “longtodolist” then I would name the view le responsible for the output of this function “longtodolist.ctp” and store it in a folder called “items” in the app > views folder. e name of the folder that holds these individual views corresponds with the name of the controller. In other words, since our controller is plural and links up with the table “items,” the view folder that houses the individual views for this controller will also be named “items.”

More Than One Word in the Title
If you need to put more than one word in the name of your controller, database table, model, or view, then the convention here is to do so with an underscore:

Don’t forget to follow these conventions, and Cake will save you a lot of time in connecting les to each other. In reality, the functionality of any framework lives and breathes on these principles of convention and consistency.

Changing the Design
You’ll notice here that because we’ve called out Cake’s sca olding feature, the design uses all of Cake’s built-in styles and layout. We can change the overall design easily without a ecting the sca olding feature itself by adjusting the views. So far the only les we’ve created were app > controllers > items_controller.php and app > models > item.php. Since the items_controller le contains the var $scaffold string, all the views have been dynamically generated. Were this not the case, Cake would go into the app > views folder and search for a directory entitled “items” to build the design. We haven’t created any yet, and it’s using the sca olding, so Cake is still able to build our application. Let’s go ahead and change the design.

How Views Work
Remember, Cake’s framework follows the MVC method: models, views, and controllers. So far, you’ve become familiar with the model and the controller. Views are separated out from the mix to provide for easier handling of output. Cake organizes all the views in the app > views folder. e views folder contains the following directories:
elements/ errors/ helpers/ layouts/ pages/

Newbie’s Introduction to CakePHP

31
scaffolds/

e layouts folder contains any overall layout les that are wrapped around your application. By creating a le named “default.ctp,” Cake knows to apply this layout instead of its own default scaffolding layout. Create the default.ctp le. In the app > views > layouts folder, create a le named “default.ctp,” and put in it your own HTML/CSS code.

SIDENOTE
In earlier versions of Cake, all view les were given the “.thtml” extension. The developers have chosen to change this to “.ctp” for better system compatibility. Currently, both extensions work, but since .thtml will eventually become deprecated, I’ve chosen to stick with .ctp in the following examples. Below is a basic, boring, HTML layout to demonstrate how layouts work:
1 2 3 4 5 6 7 8 9 10 11 12 13 <html> <head> <title>My Cake To-Do Application</title> <?=$html->css(‘styles’);?> </head> <body> <div id=”container”> <div id=”content”> <?=$content_for_layout;?> </div> </div> </body> </html>

Lines 1–3 are basic HTML tags that initiate an HTML le and its header, as well as give the page a title, in this case, “My Cake To-Do Application.” Line 4 is a bit of Cake helper code that will automatically pull in the CSS le named “styles.css” (we’ll create this le in a second). Line 5 closes the HTML le’s headers. Lines 6–8 initiate the body space and create two block-level elements with ids “container” and “content.” Lines 10–13 close these tags out. Line 9 is the key to any layout le in Cake. It’s the string that tells Cake where to put all the views. When you launch any controller that hasn’t speci ed another layout le, by default Cake will now swap out this line with whatever output you’ve generated through your controllers, models, and views. Because it is a layout le, all the surrounding HTML will be applied to all the output.
Newbie’s Introduction to CakePHP

32

Create a stylesheet for the layout. Now, in the app > webroot > css folder, create a new le named “styles.css.” is le will get pulled into the HTML les that Cake generates through the default layout (because of line 4 in the code sample above). Since it is blank, we shouldn’t see anything ashy whatsoever once the view is rendered. Now, launch the items controller, and you should now see the following screen:

Line 1, we declare a browser default of the font family. Lines 3–9 contain the styles for the <th> tag. And, nally, lines 11–13 make the list items change from a bullet to no bullet type at all. Refresh the items screen, and you’ll see something like this:

Newbie’s Introduction to CakePHP

33

You can see that by placing our own styles into the default layout, we can fully edit the design surrounding our application’s output. Any views that are rendered, if they follow the default layout, will also be rendered using the same stylesheet, so there’s no need to duplicate styles or designs. Go back to the app > views > layouts > default.ctp le, and change line 4 to the following:
4 <?=$html->css(‘cake.generic’);?>

When you refresh the items screen, you’ll notice that Cake’s styles have been implemented without the sca olding’s default titles and such:

With all these style changes, the sca olding is still generating the individual CRUD operation views but now without Cake’s built-in layouts.

Creating Individual Views
What do we do if we want to manipulate the views directly? For example, say you wanted to get rid of the title at the top that reads “List Items” and replace it with “ ings I Need To Do.” is is where individual views comes in. Yes, the sca olding is a nice treasure that makes testing out our code quick and painless, especially if all we want to do is get to playing around with our database to make sure it’s working right. But it can’t possibly read our minds, and it can only create some generic views. To add or subtract from the application output will require us to manually build such outputs. No worries—this, too, is made much easier through the use of the framework.

Here’s what’s happening in the controller. Line 4 still has the sca olding callout string, so by default, if Cake can’t nd a function in this le to match an action typed by the user (e.g., localhost/ todo/items/edit is typed in the URL, but there is no “edit” function in this le), then it will default to building the sca old. Lines 6–8 contain a new function called index. We’re now creating this function because it is the default action for every controller. For example, when I type “http://localhost/todo/items/”, Cake searches for a function in the items_controller called “index.” It’s the same as if I type “http:// localhost/todo/items/index”. Previously, we hadn’t speci ed the index action in the le, so Cake used its pre-built sca olding functions to render the index view. Now, though, lines 6–8 are speci cally telling Cake how to handle the index action request. Cake will not use the sca olding here since it will nd this function. On line 7, we’re setting a new variable to be used in the view le (which we haven’t created yet) called “items” and the value we’re giving this variable is $this->Item->findAll(). Essentially, this line is telling the model to go into the database, locate the “items” table, and nd all records that are in that table. To summarize, then, this line is telling Cake to fetch all the data in the “items” table in the database and slap it all into a variable called “items” which we will use in the view le. Line 8 closes out the function. Now, when you refresh the items controller screen, you should see an error page like so:

What just happened is that Cake e ectively located the index function you created, but was unable to nd the corresponding view le. In the second gray box, you’ll see this error message:

Newbie’s Introduction to CakePHP

35
Fatal: Confirm you have created /Users/dave/Sites/todo/app/views/items/index.ctp the file :

Cake is telling you that it looked in the app > views folder for a folder called “items” with a le called “index.ctp” in it and couldn’t nd it. at’s cause we haven’t created it yet!

REMINDER
Whenever you get missing view errors like this one, Cake simply cannot locate a view le to correspond with a function you’ve created. You can check your controller le to make sure that the function is spelled correctly or check your views folder to make sure the nested folder or le are spelled right.

Create the Index View
In the app > views folder, create a new folder called “items.” is is so that any individual view les that need to be rendered for the items controller will be fetched correctly. Next, create a le named “index.ctp” in the app > views > items folder. Insert the following code into the new index.ctp le:

Essentially, what we have done here is recreate the sca olding view (assuming you’re still using the “cake.generic.css” le instead of your own). But now that the code is right in front of us, we can toy with any aspect of it and customize it to meet our own wants. Once you’ve refreshed the items controller, you’ll see this:

Newbie’s Introduction to CakePHP

37

Now, instead of seeing an <h1> title in the view that says the generic “List Items,” it reads “ I Need To Do.” Let me explain what has happened, line by line, in your index.ctp view le.

ings

Line 1 is where the change happened with the “ ings I Need To Do” header. (I put this in there to show some measure of proof that we are not in the sca olding environment, even though it’s looking almost identical.) Lines 2–13 are the HTML strings that create the same table as the sca olding, with its header cells. Lines 14–23 are a loop through the variable we created in the controllers > items_controller.php le on line 7. Line 14 starts the loop by saying, essentially, for each record from the database that is stored in the variable “items,” create a new variable called “item.” Line 23 marks the ending point for the loop. So everything between lines 14 and 23 will repeat for each record in the database that has been stored and brought into the “items” variable. You can see that I’ve set up a table row for each “item” and that there are corresponding table cells (lines 16–21) that pull out each eld’s data in the database. Lines 26–30 create an unordered list with the link to create a new to-do list item. On line 27, there is a little bit of Cake helper code that generates links. Similar to the CSS helper string in the default.ctp layout le, this line tells Cake to generate the HTML for us, which is nice; no matter where we may move or install this application, as long as Cake is working, the link to create a new to-do item will be unbroken. (We’ll discuss Cake’s snazzy set of HTML helpers later.) Because we haven’t created any to-do list items in the database, we don’t see this e ect really take place; the $items variable is empty. Click “New Item,” create a new to-do list item, and watch Cake pull that entry into the newly customized index view.

Using Bake to Create Views
We’ve walked through how to manually create the index view. Actually, though, you should be able to get around having to type these basic CRUD functions by hand. Included with Cake is a handy console script called the Bake script (it’s found in the cake > console > libs folder, the bake.php script). Not only will it save you tons of time in generated the needed code to build these views, it will also show you some basic Cake code that will help you understand how Cake makes use of models, views, and controllers.

Getting the Bake Script Working In Our Localhost
Because we have used either MAMP or XAMPP for our localhost setup, we’ll need to con gure the command line to work with the Bake script (see “Setup Routines,” pages 19–20 for instructions on how to get started with the command line). Fix the .pro le le. e command line console will use a le, usually invisible in your OS, named “.pro le” when it executes commands. Fortunately, we can add some of our own customized environment settings to tell the console where to go when we execute Bake commands.

Newbie’s Introduction to CakePHP

38

ere are a number of ways to open the .pro le le. You can use the terminal command
$ vi .profile

to edit .pro le in the console itself. Or,
$ open .profile

will launch the .pro le le in whatever your default le editor is. However, if you’re like me, you’d probably rather edit this le in a simple plain-text editor. I like to use Panic’s Coda to open the le d i r e c t l y i n i t s p l a i n - t e x t e d i t o r w i n d o w. A s i m p l e s e a r c h o n Ve r s i o n Tr a c k e r (www.versiontracker.com) or Mac Update (www.macupdate.com) will help you nd a plain-text editor and invisible le viewer for both Mac and PC. On the Mac, the needed .pro le le is hous ed in the us er’s home direc tor y (e.g., /Users/dave/.pro le). On the PC, it will depend on what console application you’re running (e.g., C:\msys\1.0\etc\pro le). However you decide to edit the .pro le le, be sure to add the corresponding line listed below, depending on your localhost setup (one line, no returns). MAMP on a Mac.
alias cake="/applications/mamp/bin/php5/bin/php ~/Sites/todo/cake/console/cake.php"

Bake the CRUD Views
Let’s Bake the CRUD operations’ views using the Bake script. First, delete the app > views > items folder with its index.ctp le. Next, go into the app > controllers > items_controller.php le and zap the index function. Open the terminal/console application of your choice and start the Bake program like so:
$ cake bake

It will ask you what to bake:
What would you like to Bake? (M/V/C/Q)

Here, it’s asking if you want to bake a model, view, or controller, or quit. Well, we’ve already made the model and the controller for “items,” so we’ll tell it to bake the view for us. Type “v” and hit enter. Bake will now go into the database and nd all the tables there and list them numerically. Since we have only created one table (“items”), we’ll type the number 1 and hit enter. It will ask you if you want to bake the view interactively. Hit yes to see each step of the view baking. (If you select “no,” then it will overwrite existing view les; fortunately, we’ve already removed those.)
Would you like to create some scaffolded views (index, add, view, edit) for this controller?

is is what we’re looking for. Here, Bake will go through the sca old for our controller and model and put together all the code it would use “behind the scenes” but place it in our controller and view les. Hit “yes” to proceed. It will ask if you want to create views for admin routing. Type “n” for no, and hit enter.

Newbie’s Introduction to CakePHP

40
View Scaffolding Complete.

Going into your app > views folder, you’ll nd a new folder named “items” and in it will be four les built by Bake: add.ctp edit.ctp index.ctp view.ctp ese les have all the necessary code and HTML markup to render the basic CRUD functions like Cake’s sca olding. But we still need to supply the needed controller functions as well. Start the Bake program again. Tell it you want to bake a controller. Like before, it will ask you for which number table in the database from which to build the controller. Select the items table and continue. Choose “yes” when asked if you want to proceed interactively, and when it asks you if you want sca olding, choose “no.”
Would you like to include some basic class methods (index(), add(), edit(), view ())?

Yes. is will create the controller le with the code to render the index, add, edit, and view views. Since those view les are already created and in the app > views > items folder, these functions will link up with them, and the application will run just like the sca olding, except you’ll then be able to edit the code. Select no when it asks you if you want admin routing or to use a di erent model. Continue selecting “no,” except for when it asks
Would you like to use Sessions? (y/n)

and choose “yes” here. It will ask if you want to overwrite the previous “items_controller.php” le. Enter yes. Enter no when asked if you want to bake the unit test les. Open up the app > controllers > items_controller.php le, and you should now see 64 lines of new code.

Cleaning Up the Views
You may have noticed, if you tinkered around at all with the application so far, that there may be some clunky problems once you try to create and edit to-do list items. • Priority is an open eld, not a select menu with a number value. • In the index view, a 1 or 0 is displayed instead of a “Yes” or “No.” Since Bake has given us all the code we need to play with, rather than build each line, we can just edit the parts that need xing.

Newbie’s Introduction to CakePHP

43

Make the Priority Field a <select> Tag
Right now, because Priority is stored as a smallint eld type in the database, Cake is providing an open text box. It would be better, given the nature of our application, to create a select eld with predetermined values. To change this, go back to the app > views > items > add.ctp and locate line 10.
10 echo $form->input('priority');

By now you should be able to spot the problem: line 10 has the Cake Form helper creating an input eld instead of a select menu. To make the change, replace line 10 with:
10 echo $form->select('priority',array('1'=>'1','2'=>'2','3'=>'3'));

Here, we’ve inserted the Form helper’s select builder, called it “priority” for proper saving, and an array of numbers and values. You could extend this list to nine values by continuing the array following the provided sequence. Next, the app > views > items > edit.ctp le needs to be xed as well. is le is virtually identical to the add.ctp le, so the change is just as simple. Line 11 in this le are identical to line 10 in the add.ctp le. Make the exact same change by replacing line 11 with the same string we used in the add.ctp example. Now with a select menu provided, our x is complete!

Change the Index View to Better Display the Completed Field
e index view shows a 1 or 0 value for the completed eld. It would make more sense to have this read “yes” or “no” instead. To make this change, open up the app > views > items > index.ctp le and locate lines 34–36:
34 35 36 <td> <?php echo $item['Item']['completed']?> </td>

e problem here isn’t that Cake is confusing the eld; it’s that it is actually showing the value itself rather than interpreting the value. We have to interpret it for better functionality. A simple if/then statement will x this problem. PHP’s ternary operator. A simple if/then statement is incredibly common in computer programming, no matter what language you’re using. e ternary operator provides some important shorthand to make for cleaner code. Without the ternary operator, the code would look like this:
if ($item[‘Item’][‘completed’]==1) { echo “Yes”;

Newbie’s Introduction to CakePHP

44
} else { echo “No”; }

With the ternary operator, we can cut down on extra characters nicely:
echo ($item[‘Item’][‘completed’]==1 ? “Yes” : “No”);

What we have done is house the if/then statement between parentheses. e “if ” chunk of logic comes before the question mark and the “else” is designated by the colon. e echo command comes before the parentheses because no matter what the if/then statement encounters, it will output some kind of echo string. In Cake, ternary operators can make your views much easier to read and render. In this case, instead of plopping around 5 lines of code into our view, we can maintain a one-line change. So, on line 35, replace it with our ternary operator:
35 <?php echo ($item['Item']['completed']==1 ? “Yes” : “No”);?>

Launch the index view and notice that all your to-do list items have a “Yes” or “No” for the completed eld. Now that we’ve made the changes, our to-do list application is nished.

Important Points
In this chapter, we created a basic Cake application using MySQL, sca olding, and Bake. By now, you should be able to— • Setup a localhost environment • Install Cake • Create a MySQL database • Create a new Cake application • Con gure a Cake application to use the database • Create controllers, models, and views • Change the default layout of the application • Use the sca olding with database tables • Con gure and run the Bake script • Edit controllers, models, and views generated by the Bake script In building more advanced Cake applications, not much is di erent from this general routine, so it’s worthwhile to practice the operations outlined in this chapter until they’re pretty easy to do on your own.

Newbie’s Introduction to CakePHP

45

Frameworks are designed to work in this fashion: start small, then add one piece at a time. I suppose that’s the same basic philosophy of all programming, except with a framework, you start out with a lot of code already created for you, then branch out from there. As much as possible, try to let Cake do operations for you, then build out from what it gives you. You’ll nd that you truly can build applications rapidly that are every bit as powerful as enterprise so ware. In practicing the scenario used in this chapter, try increasing your speed rather than improving every little bit of functionality. At this point, if you can build this to-do list application in under ten minutes, you’ll be well-prepared for more advanced Cake application scenarios.