"Applied Rails for agile Web development" Wonderful Staff - Chapter 4

Chapter 4

Immediate

Instant gratification, INSTANT GRATIFICATION

Now let's write an extremely simple web application to verify that Rails has successfully settled on our machine. In this process, we will also briefly introduce the way of working in the Rails application.

4.1 Creating a New Application

4.1 Creating a New Application

After installing the Rails framework, you also got a new command line tool: rails. This tool can be used to construct each new Rails application.

Why do we need such a tool - I said, why not copy the most pleasant editor, start writing the application's code from the beginning? Hey ... we can do this, but Rails can change a lot of tricks behind the scenes, let us only need to make a minimum of configurations to run an application. In order for these tricks to take effect, Rails must be able to find various components in the application. As we will later (in Section 13.2, "Directory Structure" section, the original book 173) will see, which means we must create some fixed directory structure and put our code in Suitable place. Rails this command can help us create this directory structure and generate some standard Rails code.

Now let's create the first Rails application: Open the shell window and enter a place for the file system - you want to save the application directory structure where there is a place. In our example, we will create the project under a directory called Work. Therefore, we create an application called Demo in this directory. Here you have to add some care: If there is already a directory called Demo, Rails will ask if you want to overwrite the existing file.

Dave> CD Work

Work> Rails Demo

Create

Create App / APIS

CREATE APP / CONTROLLLERS

Create App / Helpers

:::::

Create log / development.log

CREATE log / test.log

WORK>

The above command creates a directory called Demo. Enter this directory listing all of its content (using the ls command in UNIX, using the dir command in Windows), you should see such a bunch of files and subdirectories:

Work> CD Demo

Demo> LS -P

Changelog App / DB / LOG / TEST /

Readme Components / DOC / PUBLIC / VENDOR /

Rakefile Config / LIB / SCRIPT /

Suddenly faced so many directories (there are also their files) may make you feel awful, but we don't have to pay attention to their existence. Now, we only need one of them, that is, the public directory.

As its name is implied, the public directory contains those files we want to expose to end users. The key file here is Dispatcher: Dispatch.cgi, Dispatch.fcgi, and Dispatch.rb. The dispenser is responsible for receiving the request from the user from the browser and boots these requests to program code in the application. These documents are important, but we don't need to touch them.

You will also see that there is a Script subdirectory in the Demo directory, where some tool scripts are stored, and we will use them during the development of applications. Now, we will use the script called Server, which will start a stand-alone Webrick [1] server, and our new Rails application will run. Then, before proceeding, let's start the application that I have written (or generated) just prepared (or generated) first. Demo> Ruby Script / Server

=> Rails Application Started on http: //

0.0.0

.0: 3000

[2005-02-26 09:16:43] Info Webrick

1.3.1

[2005-02-26 09:16:43] Info Ruby

1.8.2

(

2004-08-24

) [PowerPC-Darwin7.5.0]

[2005-02-26 09:16:43] Info Webrick :: httpserver-start: pid = 2836 port = 3000

As can be seen from the last line of starting the output information, we launched a web server on the 3000 port [2]. We can open your browser, access http: // localhost: 3000, you will see this application (Figure 4.1).

Figure 4.1 New Rails Application

We can make Webrick run in this command line window. After we write the application code later, as long as you visit in your browser, you will see the information about the command line window output. If you want to stop the running of Webrick, you can press the Ctrl-C button in the command line window.

Now, we have let the new app ran, but there is no code we write. Below, we have to change this situation.

4.2 Hello, Rails!

4.2 Hello, Rails!

Dave said: I have no way - I have to write a "Hello, World!" Program every time I have to try a new system. In Rails, this program will send our sincere greetings to your browser.

As we introduced in Chapter 2 ("Architecture of Rails Applications", RAILS is a MVC framework. Rails receives requests from the browser, interprect the request to find the appropriate controller, and then call the appropriate method in the controller. Then, the controller calls a specific view to display the result to the user. Good news is that rails has helped us to get most "pipeline code", which has been organically combined. Now, in order to write this simple "Hello, World!" Application, we need to write a controller and a view. We don't need to write a model because we don't need to handle any data. Now let's get started from the controller.

Just like new Rails applications, we can also create a controller with a script. This script name is called Generate, saved in the Script subdirectory of the Demo project. So, to create a controller named SAY, we only need to run this script in the Demo directory, pass the name of the controller into it [3]:

Demo> Ruby Script / Generate Controller Say

EXISTS APP / Controllers /

EXISTS APP / HELPERS /

Create App / Views / Say

EXISTS TEST / FUNCTIONAL /

Create App / Controllers / Say_Controller.rb

Create Test / Functional / Say_Controller_Test.rbcreate App / Helpers / Say_HELPER.RB

The script shows the files and directories they check, and the Ruby source code and directory it added. Now, we are interested in the Ruby source program that it creates, and the new directory.

We must first pay attention to the source code of the controller, which is located in the app / controllers / book_controller.rb file, let us take a look at this file:

Class SayController

end

It's hard to be small, isn't it? SayController is an empty class that inherits from ApplicationController, so it automatically owns all default controller behavior. Now we do it, we need to add some code to this controller to process user requests. What should these code do? Now nothing else - we only need an empty Action method. So, the next question is: What is the name of this method? The answer to this question is: We need to take a look at the way the Rails handles the request.

Rails and Request Urls

Rails and request URL

Like other web applications, a Rails app is associated with a URL in the user. When you point your browser to this URL, you start talking to this application, it generates a reply information for you.

However, the real situation is more complicated than this. Imagine our app to access by the following address: http: //pragprog.com/online/demo. WEB server to store this application

Figure 4.2 URL is mapped to the controller and an action

The path is quite smart, it knows: Once you see the online / demo in the path, you need to interact with our application. Anything behind this in the URL can not change this: Our application will be called. Subsequent path information will be passed to this application, the latter will use this information as the purpose of its own interior.

Rails will determine the name of the controller based on the path, and the Action name [4] that will be called inside the controller (Figure 4.2). In the path, the first part behind the application name is the controller name, the second part is the Action name (Figure 4.3).

Our First Action

Our first Action

Let's add an action called Hello to the SAY controller. The discussion from the previous section can be learned that if you create a Hello method in the SayController class, it means adding an action called Hello. But what should this method do? Now it doesn't need anything. Remember, the responsibility of the controller is to provide full information for the display of the view. In our first application, there is no information that requires a controller to provide, so an empty Action method is sufficient. Use your favorite editor to modify the SAY_CONTROLLLLER.RB file under the App / Controller directory, plus the Hello () method:

Class SayController

Def hello

end

end

Figure 4.3 Rails will request the orientation controller and action

Let us try to call it. Just find a browser window, access the following URL: http: // localhost: 3000 / Say / Hello. (Note: In the test environment, there is no application name in the path - we direct to the controller directly.) You will see a similar effect. Maybe some annoying, but this error is absolutely reasonable (except for the quirky path in the error message). We created a controller class and an action method, but did not tell Rails what to show - we still need a view. Remember the scene when we run the script to create a controller? That script helps us generate three files and a directory, this directory is the template file used to store the controller view. Here, we created a controller called SAY, so the view should be in the app / views / Say directory.

In order to complete this "Hello, World!" App, let's create a template. By default, Rails will look for template files with current Action. In our example, this means

We need to create a file called App / Views / Say / Hello.rhtml. (Why is .RHTML? We will explain later.) Now, we only put into basic HTML code.