From 0aeb2dcf13ee72a14ee5671e97252d78fd35e76b Mon Sep 17 00:00:00 2001 From: Mike Gunderloy Date: Sun, 12 Oct 2008 20:59:16 -0500 Subject: Edits and rewrites (work in progress) --- .../getting_started_with_rails.txt | 373 +++++++++++---------- 1 file changed, 198 insertions(+), 175 deletions(-) (limited to 'railties/doc/guides/getting_started_with_rails') diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt index 3259ef8a45..fa6f398dfd 100644 --- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt +++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt @@ -4,114 +4,161 @@ Getting Started With Rails This guide covers getting up and running with Ruby on Rails. After reading it, you should be familiar with: * Installing Rails, creating a new Rails application, and connecting your application to a database -* Understanding the purpose of each folder in the Rails structure -* Creating a scaffold, and explain what it is creating and why you need each element -* The basics of model, view, and controller interaction -* The basics of HTTP and RESTful design +* The general layout of a Rails application +* The basic principles of MVC (Model, View Controller) and RESTful design +* How to quickly generate the starting pieces of a Rails application. -== How to use this guide -This guide is designed for beginners who want to get started with a Rails application from scratch. It assumes that you have no prior experience using the framework. However, it is highly recommended that you *familiarize yourself with Ruby before diving into Rails*. Rails isn't going to magically revolutionize the way you write web applications if you have no experience with the language it uses. +== This Guide Assumes + +This guide is designed for beginners who want to get started with a Rails application from scratch. It does not assume that you have any prior experience with Rails. However, to get the most out of it, you need to have some prerequisites installed: + +* The link:http://www.ruby-lang.org/en/downloads/[Ruby] language +* The link:http://rubyforge.org/frs/?group_id=126[RubyGems] packaging system +* A working installation of link:http://www.sqlite.org/[SQLite] (preferred), link:http://www.mysql.com/[MySQL], or link:http://www.postgresql.org/[PostgreSQL] + +It is highly recommended that you *familiarize yourself with Ruby before diving into Rails*. You will find it much easier to follow what's going on with a Rails application if you understand basic Ruby syntax. Rails isn't going to magically revolutionize the way you write web applications if you have no experience with the language it uses. == What is Rails? -Rails is a web development framework written in the Ruby language. It is designed to make programming web applications easier by making several assumptions about what every developer needs to get started. It allows you to write less code while accomplishing more than other languages and frameworks. -== Installing Rails +Rails is a web development framework written in the Ruby language. It is designed to make programming web applications easier by making several assumptions about what every developer needs to get started. It allows you to write less code while accomplishing more than many other languages and frameworks. Longtime Rails developers also report that it makes web application development more fun. + +Rails is _opinionated software_. That is, it assumes that there is a best way to do things, and it's designed to encourage that best way - and in some cases discourage alternatives. If you learn "The Rails Way" you'll probably discover a tremendous increase in productivity. If you persist in bringing old habits from other languages to your Rails development, and trying to use patterns you learned elsewhere, you may have a less happy experience. + +The Rails philosophy includes several guiding principles: + +* DRY - "Don't Repeat Yourself" - suggests that writing the same code over and over again is a bad thing. +* Convention Over Configuration - means that Rails makes assumptions about what you want to do and how you're going to do it, rather than letting you tweak every little thing through endless configuration files. +* REST is the best pattern for web applications - organizing your application around resources and standard HTTP verbs is the fastest way to go. + +=== Models, Views, and Controllers +Rails is organized around the Model, View, Controller architecture, usually just called MVC. MVC benefits include: + +* Isolation of business logic from the user interface +* Ease of keeping code DRY +* Making it clear where different types of code belong for easier maintenance + +==== Models + +A model represents the information (data) of the application and the rules to manipulate that data. In the case of Rails, models are primarily used for managing the rules of interaction with a corresponding database table. In most cases, one table in your database will correspond to one model in your application. The bulk of your application's business logic will be concentrated in the models. + +==== Views + +Views represent the user interface of your application. In Rails, views are often HTML files with embedded Ruby code that performs tasks related solely to the presentation of the data. Views handle the job of providing data to the web browser or other tool that is used to make requests from your application. + +==== Controllers + +Controllers provide the "glue" between models and views. In Rails, controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation. + +=== REST + +The foundation of RESTful routing is generally considered to be Roy Fielding's doctoral thesis, link:http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm[Architectural Styles and the Design of Network-based Software Architectures]. Fortunately, you need not read this entire document to understand how REST works in Rails. REST, an acronym for Representational State Transfer, boils down to two main principles for our purposes: + +* Using resource identifiers (which, for the purposes of discussion, you can think of as URLs) to represent resources +* Transferring representations of the state of that resource between system components. + +For example, to a Rails application a request such as this: -`gem install rails` ++DELETE /photos/17+ -== Create a new Rails project +would be understood to refer to a photo resource with the ID of 17, and to indicate a desired action - deleting that resource. REST is a natural style for the architecture of web applications, and Rails makes it even more natural by using conventions to shield you from some of the RESTful complexities. -We're going to create a Rails project called "blog", which is the project that we will build off of for this guide. +== Creating a New Rails Project -From your terminal, type: +If you follow this guide, you'll create a Rails project called +blog+, a (very) simple weblog. Before you can start building the application, you need to make sure that you have Rails itself installed. -`rails blog` +=== Installing Rails -This will create a folder in your working directory called "blog". Open up that folder and have a look at it. For the majority of this tutorial, we will live in the app/ folder, but here's a basic rundown on the function of each folder in a Rails app: +In most cases, the easiest way to install Rails is to take advantage of RubyGems: + +[source, shell] +------------------------------------------------------- +gem install rails +------------------------------------------------------- + +NOTE: There are some special circumstances in which you might want to use an alternate installation strategy: + +* If you're working on Windows, you may find it easier to install link:http://instantrails.rubyforge.org/wiki/wiki.pl[Instant Rails]. Be aware, though, that Instant Rails releases tend to lag seriously behind the actual Rails version. Also, you will find that Rails development on Windows is overall less pleasant than on other operating systems. If at all possible, we suggest that you install a Linux virtual machine and use that for Rails development, instead of using Windows. +* If you want to keep up with cutting-edge changes to Rails, you'll want to clone the link:http://github.com/rails/rails/tree/master[Rails source code] from github. This is not recommended as an option for beginners, though. + +=== Creating the Blog Application + +Open a terminal, navigate to a folder where you have rights to create files, and type: + +[source, shell] +------------------------------------------------------- +rails blog +------------------------------------------------------- + +This will create a Rails application that uses a SQLite database for data storage. If you prefer to use MySQL, run this command instead: + +[source, shell] +------------------------------------------------------- +rails blog -d mysql +------------------------------------------------------- + +And if you're using PostgreSQL for data storage, run this command: + +[source, shell] +------------------------------------------------------- +rails blog -d postgresql +------------------------------------------------------- + +In any case, Rails will create a folder in your working directory called +blog+. Open up that folder and explore its contents. Most of the work in this tutorial will happen in the +app/+ folder, but here's a basic rundown on the function of each folder that Rails creates in a new application by default: [grid="all"] `-----------`----------------------------------------------------------------------------------------------------------------------------- File/Folder Purpose ------------------------------------------------------------------------------------------------------------------------------------------ -README This is a brief instruction manual for your application. Use it to tell others what it does, how to set it up, etc. -Rakefile -app/ Contains the controllers, models, and views for your application. We'll focus on the app folder in this guide -config/ Configure your application's runtime rules, routes, database, etc. -db/ Shows your current database schema, as well as the database migrations (we'll get into migrations shortly) -doc/ In-depth documentation for your application -lib/ Extended modules for your application (not covered in this guide) -log/ Application log files -public/ The only folder seen to the world as-is. This is where your images, javascript, stylesheets (CSS), and other static files go -script/ Scripts provided by Rails to do recurring tasks, benchmarking, plugin installation, starting the console or the web server -test/ Unit tests, fixtures, etc. (not covered in this guide) +README This is a brief instruction manual for your application. Use it to tell others what your application does, how to set it up, and so on. +Rakefile This file contains batch jobs that can be run from the terminal. +app/ Contains the controllers, models, and views for your application. You'll focus on this folder for the remainder of this guide. +config/ Configure your application's runtime rules, routes, database, and more. +db/ Shows your current database schema, as well as the database migrations. You'll learn about migrations shortly. +doc/ In-depth documentation for your application. +lib/ Extended modules for your application (not covered in this guide). +log/ Application log files. +public/ The only folder seen to the world as-is. This is where your images, javascript, stylesheets (CSS), and other static files go. +script/ Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server. +test/ Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications] tmp/ Temporary files -vendor/ Plugins folder +vendor/ The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality. ------------------------------------------------------------------------------------------------------------------------------------------- -=== Configure SQLite Database +=== Configuring a SQLite Database + +Rails comes with built-in support for SQLite, which is a lightweight flat-file based database application. While a busy production environment may overload SQLite, it works well for development and testing. Rails defaults to using a SQLite database when creating a new project, but you can always change it later. + +If you open the file +config/database.yml+ you'll see a default database configuration using SQLite. The file contains sections for three different environments in which Rails can run by default: -Rails comes with built-in support for SQLite, which is a lightweight flat-file based database application. While it is not designed for a production environment, it works well for development and testing. Rails defaults to SQLite as the database adapter when creating a new project, but you can always change it later. +* The +development+ environment is used on your development computer as you interact manually with the application +* The +test+ environment is used to run automated tests +* The +production+ environment is used when you deploy your application for the world to use. -Open up +config/database.yml+ and you'll see the following: +Here's the section of the configuration file with connection information for the development environment: --------------------------------------------------------------------- -# SQLite version 3.x -# gem install sqlite3-ruby (not necessary on OS X Leopard) +[source, ruby] +------------------------------------------------------- development: adapter: sqlite3 database: db/development.sqlite3 timeout: 5000 +------------------------------------------------------- -# Warning: The database defined as "test" will be erased and -# re-generated from your development database when you run "rake". -# Do not set this db to the same as development or production. -test: - adapter: sqlite3 - database: db/test.sqlite3 - timeout: 5000 - -production: - adapter: sqlite3 - database: db/production.sqlite3 - timeout: 5000 --------------------------------------------------------------------- +If you don't have any database set up, SQLite is the easiest to get installed. If you're on OS X 10.5 or greater on a Mac, you already have it. Otherwise, you can install it using RubyGems: If you're not running OS X 10.5 or greater, you'll need to install the SQLite gem. Similar to installing Rails you just need to run: -`gem install sqlite3-ruby` - -Because we're using SQLite, there's really nothing else you need to do to setup your database! - -=== Configure MySQL Database - -.MySQL Tip -******************************* -If you want to skip directly to using MySQL on your development machine, typing the following will get you setup with a MySQL configuration file that assumes MySQL is running locally and that the root password is blank: - -`rails blog -d mysql` +[source, shell] +------------------------------------------------------- +gem install sqlite3-ruby +------------------------------------------------------- -You'll need to make sure you have MySQL up and running on your system with the correct permissions. MySQL installation and configuration is outside the scope of this document. -******************************* +=== Configuring a MySQL Database -If you choose to use MySQL, your +config/database.yml+ will look a little different: +If you choose to use MySQL, your +config/database.yml+ will look a little different. Here's the development section: --------------------------------------------------------------------- -# MySQL. Versions 4.1 and 5.0 are recommended. -# -# Install the MySQL driver: -# gem install mysql -# On Mac OS X: -# sudo gem install mysql -- --with-mysql-dir=/usr/local/mysql -# On Mac OS X Leopard: -# sudo env ARCHFLAGS="-arch i386" gem install mysql -- --with-mysql-config=/usr/local/mysql/bin/mysql_config -# This sets the ARCHFLAGS environment variable to your native architecture -# On Windows: -# gem install mysql -# Choose the win32 build. -# Install MySQL and put its /bin directory on your path. -# -# And be sure to use new-style password hashing: -# http://dev.mysql.com/doc/refman/5.0/en/old-client.html +[source, ruby] +------------------------------------------------------- development: adapter: mysql encoding: utf8 @@ -119,62 +166,34 @@ development: username: root password: socket: /tmp/mysql.sock +------------------------------------------------------- +If your development computer's MySQL installation includes a root user with an empty password, this configuration should work for you. Otherwise, change the username and password in the +development+ section as appropriate. -# Warning: The database defined as "test" will be erased and -# re-generated from your development database when you run "rake". -# Do not set this db to the same as development or production. -test: - adapter: mysql - encoding: utf8 - database: blog_test - username: root - password: - socket: /tmp/mysql.sock - -production: - adapter: mysql - encoding: utf8 - database: blog_production - username: root - password: - socket: /tmp/mysql.sock ----------------------------------------------------------------------- - -== Starting the web server -Rails comes bundled with the lightweight Webrick web server, which (like SQLite) works great in development mode, but is not designed for a production environment. If you install Mongrel with `gem install mongrel`, Rails will use the Mongrel web server as the default instead (recommended). -******************* -If you're interested in alternative web servers for development and/or production, check out mod_rails (a.k.a Passenger) -******************* -Rails lets you run in development, test, and production environments (you can also add an unlimited number of additional environments if necessary). In this guide, we're going to work with the development environment only, which is the default when starting the server. From the root of your application folder, simply type the following to startup the web server: - -`./script/server` +=== Configuring a PostgreSQL Database -This will start a process that allows you to connect to your application via a web browser on port 3000. Open up a browser to +http://localhost:3000/+ +If you choose to use PostgreSQL, your +config/database.yml+ will be customized to use PostgreSQL databases: -You can hit Ctrl+C anytime from the terminal to stop the web server. - -You should see the "Welcome Aboard" default Rails screen, and can click on the "About your application's environment" link to see a brief summary of your current configuration. If you've gotten this far, you're riding rails! Let's dive into the code! - -== Models, Views, and Controllers -Rails uses Model, View, Controller (MVC) architecture because it isolates business logic from the user interface, ensuring that changes to a template will not affect the underlying code that makes it function. It also helps keep your code clean and DRY (Don't Repeat Yourself!) by making it perfectly clear where different types of code belong. - -=== The Model -The model represents the information (data) of the application and the rules to manipulate that data. In the case of Rails, models are primarily used for managing the rules of interaction with a corresponding database table. Assume that for every table in your database, you will have a corresponding model (not necessarily the other way around, but that's beyond the scope of this guide). +[source, ruby] +------------------------------------------------------- +development: + adapter: postgresql + encoding: unicode + database: blog_development + username: blog + password: +------------------------------------------------------- -Models in Rails use a singular name, and their corresponding database tables use a plural name. In the case of our "Blog" application, we're going to need a table for our blog posts. Because we're generating a model, we want to use the singular name: +Change the username and password in the +development+ section as appropriate. -`./script/generate model Post` +== Getting Up and Running Quickly With Scaffolding -You'll see that this generates several files, we're going to focus on two. First, let's take a look at +app/models/post.rb+ +Whenever you are dealing with a resource and you know you'll need a way to manage that resource in your application, you can start by generating a scaffold. The reason that this guide did not start with generating the scaffold is because it is not all that useful once you are using Rails on a regular basis. For our blog, we want a "Post" resource, so let's generate that now: -------------------------------- -class Post < ActiveRecord::Base -end -------------------------------- +`./script/generate scaffold Post name:string title:string content:text` -This is what each model you create will look like by default. Here Rails is making the assumption that your Post model will be tied to a database, because it is telling the Post class to descend from the ActiveRecord::Base class, which is where all the database magic happens. Let's leave the model alone for now and move onto migrations. +This generates the model, controller, migration, views, tests, and routes for this resource. It also populates these files with default data to get started. -==== Migrations +=== Migrations Database migrations make it simple to add/remove/modify tables, columns, and indexes while allowing you to roll back or forward between states with ease. Have a look at +db/migrate/2008XXXXXXXXXX_create_posts.rb+ (Yours will have numbers specific to the time that the file was generated), which was generated when creating our Post model: @@ -226,51 +245,6 @@ This command will always run any migrations that have not yet been run. Rails is very smart, it knows that if you have a model "Person," the database table should be called "people". If you have a model "Company", the database table will be called "companies". There are a few circumstances where it will not know the correct singular and plural of a model name, but you should have no problem with this as long as you are using common English words. Fixing these rare circumstances is beyond the scope of this guide. ************************************************************************************************************** -=== The Controller -The controller communicates input from the user (the view) to the model. - -==== RESTful Design -The REST idea will likely take some time to wrap your brain around if you're new to the concept. But know the following: - -* It is best to keep your controllers RESTful at all times if possible -* Resources must be defined in +config/routes.rb+ in order for the RESTful architecture to work properly, so let's add that now: - --------------------- -map.resources :posts --------------------- - -* The seven actions that are automatically part of the RESTful design in Rails are +index+, +show+, +new+, +create+, +edit+, +update+, and +destroy+. - -Let's generate a controller: - -`./script/generate controller Posts` - -Open up the controller that it generates in +app/controllers/posts_controller.rb+. It should look like: - ---------------------------------------------- -class PostsController < ApplicationController -end ---------------------------------------------- - -Because of the +map.resources :posts+ line in your +config/routes.rb+ file, this controller is ready to take on all seven actions listed above. But we're going to need some logic in this controller in order to interact with the model, and we're going to need to generate our view files so the user can interact with your application from their browser. - -We're going to use the scaffold generator to create all the files and basic logic to make this work, now that you know how to generate models and controllers manually. - -To do that, let's completely start over. Back out of your Rails project folder, and *remove it completely* (`rm -rf blog`). -Create the project again and enter the directory by running the commands: - -`rails blog` - -`cd blog` - - -=== Rails Scaffold -Whenever you are dealing with a resource and you know you'll need a way to manage that resource in your application, you can start by generating a scaffold. The reason that this guide did not start with generating the scaffold is because it is not all that useful once you are using Rails on a regular basis. For our blog, we want a "Post" resource, so let's generate that now: - -`./script/generate scaffold Post name:string title:string content:text` - -This generates the model, controller, migration, views, tests, and routes for this resource. It also populates these files with default data to get started. - First, let's make sure our database is up to date by running `rake db:migrate`. That may generate an error if your database still has the tables from our earlier migration. In this case, let's completely reset the database and run all migrations by running `rake db:reset`. Start up the web server with `./script/server` and point your browser to `http://localhost:3000/posts`. @@ -279,7 +253,7 @@ Here you'll see an example of the instant gratification of Rails where you can c Now let's see how all this works. Open up `app/controllers/posts_controller.rb`, and you'll see this time it is filled with code. -==== Index +=== Index Let's take a look at the `index` action: @@ -298,7 +272,7 @@ In this action, we're setting the `@posts` instance variable to a hash of all po The `respond_to` block handles both HTML and XML calls to this action. If we call `http://localhost:3000/posts.xml`, we'll see all our posts in XML format. The HTML format looks for our corresponding view in `app/views/posts/index.html.erb`. You can add any number of formats to this block to allow actions to be processed with different file types. -==== Show +=== Show Back in your browser, click on the "New post" link and create your first post if you haven't done so already. Return back to the index, and you'll see the details of your post listed, along with three actions to the right of the post: `show`, `edit`, and `destroy`. Click the `show` link, which will bring you to the URL `http://localhost:3000/posts/1`. Now let's look at the `show` action in `app/controllers/posts_controller.rb`: @@ -315,7 +289,7 @@ end This time, we're setting `@post` to a single record in the database that is searched for by its `id`, which is provided to the controller by the "1" in `http://localhost:3000/posts/1`. The `show` action is ready to handle HTML or XML with the `respond_to` block: XML can be accessed at: `http://localhost:3000/posts/1.xml`. -==== New & Create +=== New & Create In your controller, you'll see the `new` and `create` actions, which are used together to create a new record. Our `new` action simply instantiates a new Post object without any parameters: @@ -354,18 +328,67 @@ def create end --------------------------------------- -==== Edit & Update +=== Edit & Update For the `edit`, `update`, and `destroy` actions, we will use the same `@post = Post.find(params[:id])` to find the appropriate record. -==== Destroy +=== Destroy Description of the destroy action -=== The View -The view is where you put all the code that gets seen by the user: divs, tables, text, checkboxes, etc. Think of the view as the home of your HTML. If done correctly, there should be no business logic in the view. +== Starting the web server +Rails comes bundled with the lightweight Webrick web server, which (like SQLite) works great in development mode, but is not designed for a production environment. If you install Mongrel with `gem install mongrel`, Rails will use the Mongrel web server as the default instead (recommended). +******************* +If you're interested in alternative web servers for development and/or production, check out mod_rails (a.k.a Passenger) +******************* +Rails lets you run in development, test, and production environments (you can also add an unlimited number of additional environments if necessary). In this guide, we're going to work with the development environment only, which is the default when starting the server. From the root of your application folder, simply type the following to startup the web server: + +`./script/server` + +This will start a process that allows you to connect to your application via a web browser on port 3000. Open up a browser to +http://localhost:3000/+ + +You can hit Ctrl+C anytime from the terminal to stop the web server. + +You should see the "Welcome Aboard" default Rails screen, and can click on the "About your application's environment" link to see a brief summary of your current configuration. If you've gotten this far, you're riding rails! Let's dive into the code! + +== Adding a Second Model + +== Generating a Model + +Models in Rails use a singular name, and their corresponding database tables use a plural name. In the case of our "Blog" application, we're going to need a table for our blog posts. Because we're generating a model, we want to use the singular name: + +`./script/generate model Post` + +You'll see that this generates several files, we're going to focus on two. First, let's take a look at +app/models/post.rb+ + +------------------------------- +class Post < ActiveRecord::Base +end +------------------------------- + +This is what each model you create will look like by default. Here Rails is making the assumption that your Post model will be tied to a database, because it is telling the Post class to descend from the ActiveRecord::Base class, which is where all the database magic happens. Let's leave the model alone for now and move onto migrations. + +=== Associating Models + +=== Generating a Controller + +=== Building Views + +== What's Next? + +Now that you've seen your first Rails application, you should feel free to update it and experiment on your own. But you don't have to do everything without help. As you need assistance getting up and running with Rails, feel free to consult these support resources: + +* The [http://manuals.rubyonrails.org/]Ruby On Rails guides +* The link:http://groups.google.com/group/rubyonrails-talk[Ruby on Rails mailing list] +* The #rubyonrails channel on irc.freenode.net +* The link:http://wiki.rubyonrails.org/rails[Rails wiki] + +== Changelog == +http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/2[Lighthouse ticket] +* October 12, 2008: More detail, rearrangement, editing by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) +* September 8, 2008: initial version by James Miller (not yet approved for publication) -- cgit v1.2.3 From 9768325def9f9371094f134f274ff98d1f60ba47 Mon Sep 17 00:00:00 2001 From: Mike Gunderloy Date: Mon, 13 Oct 2008 19:31:37 -0500 Subject: First complete draft of "getting started" guide --- .../getting_started_with_rails.txt | 719 ++++++++++++++++++--- 1 file changed, 619 insertions(+), 100 deletions(-) (limited to 'railties/doc/guides/getting_started_with_rails') diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt index fa6f398dfd..88f99e73c7 100644 --- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt +++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt @@ -109,19 +109,19 @@ In any case, Rails will create a folder in your working directory called +blog+. `-----------`----------------------------------------------------------------------------------------------------------------------------- File/Folder Purpose ------------------------------------------------------------------------------------------------------------------------------------------ -README This is a brief instruction manual for your application. Use it to tell others what your application does, how to set it up, and so on. -Rakefile This file contains batch jobs that can be run from the terminal. -app/ Contains the controllers, models, and views for your application. You'll focus on this folder for the remainder of this guide. -config/ Configure your application's runtime rules, routes, database, and more. -db/ Shows your current database schema, as well as the database migrations. You'll learn about migrations shortly. -doc/ In-depth documentation for your application. -lib/ Extended modules for your application (not covered in this guide). -log/ Application log files. -public/ The only folder seen to the world as-is. This is where your images, javascript, stylesheets (CSS), and other static files go. -script/ Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server. -test/ Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications] -tmp/ Temporary files -vendor/ The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality. ++README+ This is a brief instruction manual for your application. Use it to tell others what your application does, how to set it up, and so on. ++Rakefile+ This file contains batch jobs that can be run from the terminal. ++app/+ Contains the controllers, models, and views for your application. You'll focus on this folder for the remainder of this guide. ++config/+ Configure your application's runtime rules, routes, database, and more. ++db/+ Shows your current database schema, as well as the database migrations. You'll learn about migrations shortly. ++doc/+ In-depth documentation for your application. ++lib/+ Extended modules for your application (not covered in this guide). ++log/+ Application log files. ++public/+ The only folder seen to the world as-is. This is where your images, javascript, stylesheets (CSS), and other static files go. ++script/+ Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server. ++test/+ Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications] ++tmp/+ Temporary files ++vendor/+ The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality. ------------------------------------------------------------------------------------------------------------------------------------------- === Configuring a SQLite Database @@ -187,43 +187,58 @@ Change the username and password in the +development+ section as appropriate. == Getting Up and Running Quickly With Scaffolding -Whenever you are dealing with a resource and you know you'll need a way to manage that resource in your application, you can start by generating a scaffold. The reason that this guide did not start with generating the scaffold is because it is not all that useful once you are using Rails on a regular basis. For our blog, we want a "Post" resource, so let's generate that now: +Rails _scaffolding_ is a quick way to generate some of the major pieces of an application. If you want to create the models, views, and controllers for a new resource in a single operation, scaffolding is the tool for the job. -`./script/generate scaffold Post name:string title:string content:text` +== Creating a Resource -This generates the model, controller, migration, views, tests, and routes for this resource. It also populates these files with default data to get started. +In the case of the blog application, I'll start by generating a scaffolded Post resource: this will represent a single blog posting. To do this, enter this command in your terminal: -=== Migrations -Database migrations make it simple to add/remove/modify tables, columns, and indexes while allowing you to roll back or forward between states with ease. +[source, shell] +------------------------------------------------------- +script/generate scaffold Post name:string title:string content:text +------------------------------------------------------- -Have a look at +db/migrate/2008XXXXXXXXXX_create_posts.rb+ (Yours will have numbers specific to the time that the file was generated), which was generated when creating our Post model: +TIP: If you're on Windows, or your Ruby is set up in some non-standard fashion, you may need to explicitly pass Rails +script+ commands to Ruby: +ruby script/generate scaffold Post name:string title:string content:text+. -------------------------------------------- -class CreatePosts < ActiveRecord::Migration - def self.up - create_table :posts do |t| +NOTE: While scaffolding will get you up and running quickly, the "one size fits all" code that it generates is unlikely to be a perfect fit for your application. In most cases, you'll need to customize the generated code. Many experienced Rails developers avoid scaffolding entirely, preferring to write all or most of their source code from scratch. - t.timestamps - end - end +The scaffold generator will build 13 files in your application, along with some folders, and edit one more. Here's a quick overview of what it creates: - def self.down - drop_table :posts - end -end -------------------------------------------- +[grid="all"] +`---------------------------------------------`-------------------------------------------------------------------------------------------- +File Purpose +------------------------------------------------------------------------------------------------------------------------------------------ +app/models/post.rb The Post model +db/migrate/20081013124235_create_posts.rb Migration to create the posts table in your database (your name will include a different timestamp) +app/views/posts/index.html.erb A view to display an index of all posts +app/views/posts/show.html.erb A view to display a single post +app/views/posts/new.html.erb A view to create a new post +app/views/posts/edit.html.erb A view to edit an existing post +app/views/layouts/posts.html.erb A view to control the overall look and feel of the other posts views +public/stylesheets/scaffold.css Cascading style sheet to make the scaffolded views look better +app/controllers/posts_controller.rb The Posts controller +test/functional/posts_controller_test.rb Functional testing harness for the posts controller +app/helpers/posts_helper.rb Helper functions to be used from the posts views +config/routes.rb Edited to include routing information for posts +test/fixtures/posts.yml Dummy posts for use in testing +test/unit/post_test.rb Unit testing harness for the posts model +------------------------------------------------------------------------------------------------------------------------------------------- + +=== Running a Migration -By default, Rails creates a database migration that will create the table for "posts" (plural name of model). The +create_table+ method takes a ruby block, and by default you'll see +t.timestamps+ in there, which automatically creates and automatically handles +created_at+ and +updated_at+ datetime columns. The +self.up+ section handles progression of the database, whereas the +self.down+ handles regression (or rollback) of the migration. +One of the products of the +script/generate scaffold+ command is a _database migration_. Migrations are Ruby classes that are designed to make it simple to create and modify database tables. Rails uses rake commands to run migrations, and it's possible to undo a migration after it's been applied to your database. Migration filenames include a timestamp to ensure that they're processed in the order that they were created. -Let's add some more columns to our migration that suit our post table. We'll create a +name+ column for the person who wrote the post, a +title+ column for the title of the post, and a +content+ column for the actual post content. +If you look in the +db/migrate/20081013124235_create_posts.rb+ file (remember, yours will have a slightly different name), here's what you'll find: -------------------------------------------- +[source, ruby] +------------------------------------------------------- class CreatePosts < ActiveRecord::Migration def self.up create_table :posts do |t| - t.string :name - t.string :title - t.text :content + t.string :name + t.string :title + t.text :content + t.timestamps end end @@ -232,32 +247,61 @@ class CreatePosts < ActiveRecord::Migration drop_table :posts end end -------------------------------------------- +------------------------------------------------------- -Now that we have our migration just right, we can run the migration (the +self.up+ portion) by returning to the terminal and running: +If you were to translate that into words, it says something like: when this migration is run, create a table named +posts+ with two string columns (+name+ and +title+) and a text column (+content+), and generate timestamp fields to track record creation and updating. You can learn the detailed syntax for migrations in the link:../migrations/migrations.html[Rails Database Migrations] guide. -`rake db:migrate` +At this point, you need to do two things: create the database and run the migration. You can use rake commands at the terminal for both of those tasks: -This command will always run any migrations that have not yet been run. +[source, shell] +------------------------------------------------------- +rake db:create +rake db:migrate +------------------------------------------------------- -.Singular and Plural Inflections -************************************************************************************************************** -Rails is very smart, it knows that if you have a model "Person," the database table should be called "people". If you have a model "Company", the database table will be called "companies". There are a few circumstances where it will not know the correct singular and plural of a model name, but you should have no problem with this as long as you are using common English words. Fixing these rare circumstances is beyond the scope of this guide. -************************************************************************************************************** +NOTE: Because you're working in the development environment by default, both of these commands will apply to the database defined in the +development+ section of your +config/database.yml+ file. + +=== Starting the Web Server + +You actually have a pretty functional Rails application already - after running only four commands! To see it, you need to start a web server on your development machine. You can do this by running another command: + +[source, shell] +------------------------------------------------------- +script/server +------------------------------------------------------- + +This will fire up the lightweight Webrick web server by default. To see your application in action, open a browser window and navigate to +http://localhost:3000+. You should see Rails' default information page: -First, let's make sure our database is up to date by running `rake db:migrate`. That may generate an error if your database still has the tables from our earlier migration. In this case, let's completely reset the database and run all migrations by running `rake db:reset`. +image:images/rails_welcome.png[Welcome Aboard screenshot] -Start up the web server with `./script/server` and point your browser to `http://localhost:3000/posts`. +TIP: To stop the web server, hit Ctrl+C in the terminal window where it's running. In development mode, Rails does not generally require you to stop the server; changes you make in files will be automatically picked up by the server. -Here you'll see an example of the instant gratification of Rails where you can completely manage the Post resource. You'll be able to create, edit, and delete blog posts with ease. Go ahead, try it out. +The "Welcome Aboard" page is the smoke test for a new Rails application: it makes sure that you have your software configured correctly enough to serve a page. But you probably wanted to see something about posts. To do that, navigate to +http://localhost:3000/posts+: -Now let's see how all this works. Open up `app/controllers/posts_controller.rb`, and you'll see this time it is filled with code. +image:images/posts_index.png[Posts Index screenshot] -=== Index +This is the result of Rails rendering the +index+ view of your posts. There aren't currently any posts in the database, but if you click the +New Post+ link you can create one. After that, you'll find that you can edit posts, look at their details, or destroy them. All of the logic and HTML to handle this was built by the single +script/generate scaffold+ command. -Let's take a look at the `index` action: +Congratulations, you're riding the rails! Now it's time to see how it all works. ------------------------------------------ +=== The Model + +The model file, +app/models/post.rb+ is about as simple as it can get: + +[source, ruby] +------------------------------------------------------- +class Post < ActiveRecord::Base +end +------------------------------------------------------- + +There isn't much to this file - but note that the +Post+ class inherits from +ActiveRecord::Base+. Active Record supplies a great deal of functionality to your Rails models for free, including basic database CRUD (Create, Read, Update, Destroy) operations, data validation, as well as sophisticated search support and the ability to relate multiple models to one another. + +=== Listing All Posts + +The easiest place to start looking at functionality is with the code that lists all posts. Open the file +app/controllers/posts_controller.rb + and look at the +index+ action: + +[source, ruby] +------------------------------------------------------- def index @posts = Post.find(:all) @@ -266,34 +310,56 @@ def index format.xml { render :xml => @posts } end end ------------------------------------------ +------------------------------------------------------- -In this action, we're setting the `@posts` instance variable to a hash of all posts in the database. `Post.find(:all)` or `Post.all` (in Rails 2.1) calls on our model to return all the Posts in the database with no additional conditions. +This code sets the +@posts+ instance variable to an array of all posts in the database. +Post.find(:all)+ or +Post.all+ calls the +Post+ model to return all of the posts that are currently in the database, with no limiting conditions. -The `respond_to` block handles both HTML and XML calls to this action. If we call `http://localhost:3000/posts.xml`, we'll see all our posts in XML format. The HTML format looks for our corresponding view in `app/views/posts/index.html.erb`. You can add any number of formats to this block to allow actions to be processed with different file types. +TIP: For more information on finding records with Active Record, see link:../activerecord/finders.html[Active Record Finders]. -=== Show +The +respond_to+ block handles both HTML and XML calls to this action. If you borwse to +http://localhost:3000/posts.xml+, you'll see all of the posts in XML format. The HTML format looks for a view in +app/views/posts/+ with a name that corresponds to the action name. Rails makes all of the instance variables from the action available to the view. Here's +app/view/posts/index.html.erb+: -Back in your browser, click on the "New post" link and create your first post if you haven't done so already. Return back to the index, and you'll see the details of your post listed, along with three actions to the right of the post: `show`, `edit`, and `destroy`. Click the `show` link, which will bring you to the URL `http://localhost:3000/posts/1`. Now let's look at the `show` action in `app/controllers/posts_controller.rb`: +[source, ruby] +------------------------------------------------------- +

Listing posts

+ + + + + + + + +<% for post in @posts %> + + + + + + + + +<% end %> +
NameTitleContent
<%=h post.name %><%=h post.title %><%=h post.content %><%= link_to 'Show', post %><%= link_to 'Edit', edit_post_path(post) %><%= link_to 'Destroy', post, :confirm => 'Are you sure?', :method => :delete %>
+ +
+ +<%= link_to 'New post', new_post_path %> +------------------------------------------------------- ------------------------------------------ -def show - @post = Post.find(params[:id]) +This view iterates over the contents of the +@posts+ array to display content and links. A few things to note in the view: - respond_to do |format| - format.html # show.html.erb - format.xml { render :xml => @post } - end -end ------------------------------------------ +* +h+ is a Rails helper method to sanitize displayed data, preventing cross-site scripting attacks +* +link_to+ builds a hyperlink to a particular destination +* +edit_post_path+ is a helper that Rails provides as part of RESTful routing. -This time, we're setting `@post` to a single record in the database that is searched for by its `id`, which is provided to the controller by the "1" in `http://localhost:3000/posts/1`. The `show` action is ready to handle HTML or XML with the `respond_to` block: XML can be accessed at: `http://localhost:3000/posts/1.xml`. +TIP: For more details on the rendering process, see link:../actionview/layouts_and_rendering [Layouts and Rendering in Rails]. -=== New & Create +=== Creating New Posts -In your controller, you'll see the `new` and `create` actions, which are used together to create a new record. Our `new` action simply instantiates a new Post object without any parameters: +Creating a new post involves two actions. The first is the +new+ action, which instantiates an empty +Post+ object: ------------------------------------------ +[source, ruby] +------------------------------------------------------- def new @post = Post.new @@ -302,16 +368,43 @@ def new format.xml { render :xml => @post } end end ----------------------------------------- +------------------------------------------------------- -Our `create` action, on the other hand, instantiates a new Post object while setting its attributes to the parameters that we specify in our form. It then uses a `flash[:notice]` to inform the user of the status of the action. If the Post is saved successfully, the action will redirect to the `show` action containing our new Post simply by calling the simple `redirect_to(@post)`. +The +new.html.erb+ view displays this empty Post to the user: -.The Flash -************************************************************************************************************** -Rails provides the Flash so that messages can be carried over to another action, providing the user with useful information on the status of their request. In our `create` example, the user never actually sees any page rendered during the Post creation process, because it immediately redirects to the new Post as soon as the record is saved. The Flash allows us to carry over a message to the next action, so once the user is redirected back to the `show` action, they are presented with a message saying "Post was successfully created." -************************************************************************************************************** +[source, ruby] +------------------------------------------------------- +

New post

+ +<% form_for(@post) do |f| %> + <%= f.error_messages %> + +

+ <%= f.label :name %>
+ <%= f.text_field :name %> +

+

+ <%= f.label :title %>
+ <%= f.text_field :title %> +

+

+ <%= f.label :content %>
+ <%= f.text_area :content %> +

+

+ <%= f.submit "Create" %> +

+<% end %> + +<%= link_to 'Back', posts_path %> +------------------------------------------------------- ----------------------------------------- +The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed. + +When the user clicks the +Create+ button on this form, the browser will send information back to the +create+ method of the controller (Rails knows to call the +create+ method because the form is sent with an HTTP POST request; that's one of the conventions that I mentioned earlier): + +[source, ruby] +------------------------------------------------------- def create @post = Post.new(params[:post]) @@ -326,54 +419,479 @@ def create end end end ---------------------------------------- +------------------------------------------------------- -=== Edit & Update +The +create+ action instantiates a new Post object from the data supplied by the user on the form, which Rails makes available in the +params+ hash. After saving the new post, it uses +flash[:notice]+ to create an informational message for the user, and redirects to the show action for the post. If there's any problem, the +create+ action just shows the +new+ view a second time, with any error messages. -For the `edit`, `update`, and `destroy` actions, we will use the same `@post = Post.find(params[:id])` to find the appropriate record. +.The Flash +************************************************************************************************************** +Rails provides the +flash+ hash (usually just called the Flash) so that messages can be carried over to another action, providing the user with useful information on the status of their request. In the case of +create+, the user never actually sees any page rendered during the Post creation process, because it immediately redirects to the new Post as soon Rails saves the record. The Flash carries over a message to the next action, so that when the user is redirected back to the +show+ action, they are presented with a message saying "Post was successfully created." +************************************************************************************************************** -=== Destroy +=== Showing an Individual Post -Description of the destroy action +When you click the +show+ link for a post on the index page, it will bring you to a URL like +http://localhost:3000/posts/1+. Rails interprets this as a call to the +show+ action for the resource, and passes in +1+ as the +:id+ parameter. Here's the +show+ action: -== Starting the web server -Rails comes bundled with the lightweight Webrick web server, which (like SQLite) works great in development mode, but is not designed for a production environment. If you install Mongrel with `gem install mongrel`, Rails will use the Mongrel web server as the default instead (recommended). -******************* -If you're interested in alternative web servers for development and/or production, check out mod_rails (a.k.a Passenger) -******************* -Rails lets you run in development, test, and production environments (you can also add an unlimited number of additional environments if necessary). In this guide, we're going to work with the development environment only, which is the default when starting the server. From the root of your application folder, simply type the following to startup the web server: +[source, ruby] +------------------------------------------------------- +def show + @post = Post.find(params[:id]) + + respond_to do |format| + format.html # show.html.erb + format.xml { render :xml => @post } + end +end +------------------------------------------------------- + +The +show+ action uses +Post.find+ to search for a single record in the database by its id value. After finding the record, Rails displays it by using +show.html.erb+: + +[source, ruby] +------------------------------------------------------- +

+ Name: + <%=h @post.name %> +

+ +

+ Title: + <%=h @post.title %> +

+ +

+ Content: + <%=h @post.content %> +

-`./script/server` -This will start a process that allows you to connect to your application via a web browser on port 3000. Open up a browser to +http://localhost:3000/+ +<%= link_to 'Edit', edit_post_path(@post) %> | +<%= link_to 'Back', posts_path %> +------------------------------------------------------- + +=== Editing Posts -You can hit Ctrl+C anytime from the terminal to stop the web server. +Like creating a new post, editing a post is a two-part process. The first step is a request to +edit_post_path(@post)+ with a particular post. This calls the +edit+ action in the controller: + +[source, ruby] +------------------------------------------------------- +def edit + @post = Post.find(params[:id]) +end +------------------------------------------------------- + +After finding the requested post, Rails uses the +edit.html.erb+ view to display it: + +[source, ruby] +------------------------------------------------------- +

Editing post

+ +<% form_for(@post) do |f| %> + <%= f.error_messages %> + +

+ <%= f.label :name %>
+ <%= f.text_field :name %> +

+

+ <%= f.label :title %>
+ <%= f.text_field :title %> +

+

+ <%= f.label :content %>
+ <%= f.text_area :content %> +

+

+ <%= f.submit "Update" %> +

+<% end %> + +<%= link_to 'Show', @post %> | +<%= link_to 'Back', posts_path %> +------------------------------------------------------- + +Submitting the form created by this view will invoke the +update+ action within the controller: + +[source, ruby] +------------------------------------------------------- +def update + @post = Post.find(params[:id]) + + respond_to do |format| + if @post.update_attributes(params[:post]) + flash[:notice] = 'Post was successfully updated.' + format.html { redirect_to(@post) } + format.xml { head :ok } + else + format.html { render :action => "edit" } + format.xml { render :xml => @post.errors, :status => :unprocessable_entity } + end + end +end +------------------------------------------------------- + +In the +update+ action, Rails first uses the +:id+ parameter passed back from the edit view to locate the database record that's being edited. The +update_attributes+ call then takes the rest of the parameters from the request and applies them to this record. If all goes well, the user is redirected to the post's +show+ view. If there are any problems, it's back to +edit+ to correct them. + +NOTE: Sharp-eyed readers will have noticed that the +form_for+ declaration is identical for the +create+ and +edit+ views. Rails generates different code for the two forms because it's smart enough to notice that in the one case it's being passed a new record that has never been saved, and in the other case an existing record that has already been saved to the database. + +=== Destroying a Post + +Finally, clicking one of the +destroy+ links sends the associated id to the +destroy+ action: + +[source, ruby] +------------------------------------------------------- +def destroy + @post = Post.find(params[:id]) + @post.destroy + + respond_to do |format| + format.html { redirect_to(posts_url) } + format.xml { head :ok } + end +end +------------------------------------------------------- -You should see the "Welcome Aboard" default Rails screen, and can click on the "About your application's environment" link to see a brief summary of your current configuration. If you've gotten this far, you're riding rails! Let's dive into the code! +The +destroy+ method of an Active Record model instance removes the corresponding record from the database. After that's done, there isn't any record to display, so Rails redirects the user's browser to the index view for the model. == Adding a Second Model -== Generating a Model +Now that you've seen what's in a model built with scaffolding, it's time to add a second model to the application. The second model will handle comments on blog posts. -Models in Rails use a singular name, and their corresponding database tables use a plural name. In the case of our "Blog" application, we're going to need a table for our blog posts. Because we're generating a model, we want to use the singular name: +=== Generating a Model -`./script/generate model Post` +Models in Rails use a singular name, and their corresponding database tables use a plural name. For the model to hold comments, the convention is to use the name Comment. Even if you don't want to use the entire apparatus set up by scaffolding, most Rails developers still use generators to make things like models and controllers. To create the new model, run this command in your terminal: -You'll see that this generates several files, we're going to focus on two. First, let's take a look at +app/models/post.rb+ +[source, shell] +------------------------------------------------------- +script/generate model Comment commenter:string body:text post:references +------------------------------------------------------- -------------------------------- -class Post < ActiveRecord::Base +This command will generate four files: + +* +app/models/comment.rb+ - The model +* +db/migrate/20081013214407_create_comments.rb - The migration +* +test/unit/comment_test.rb+ and +test/fixtures/comments.yml+ - The test harness. + +First, take a look at +comment.rb+: + +[source, ruby] +------------------------------------------------------- +class Comment < ActiveRecord::Base + belongs_to :post end -------------------------------- +------------------------------------------------------- + +This is very similar to the +post.rb+ model that you saw earlier. The difference is the line +belongs_to :post+, which sets up an Active Record _association_. You'll learn a little about associations in the next section of this guide. -This is what each model you create will look like by default. Here Rails is making the assumption that your Post model will be tied to a database, because it is telling the Post class to descend from the ActiveRecord::Base class, which is where all the database magic happens. Let's leave the model alone for now and move onto migrations. +In addition to the model, Rails has also made a migration to create the corresponding database table: + +[source, ruby] +------------------------------------------------------- +class CreateComments < ActiveRecord::Migration + def self.up + create_table :comments do |t| + t.string :commenter + t.text :body + t.references :post + + t.timestamps + end + end + + def self.down + drop_table :comments + end +end +------------------------------------------------------- + +The +t.references+ line sets up a foreign key column for the association between the two models. Go ahead and run the migration: + +[source, shell] +------------------------------------------------------- +rake db:migrate +------------------------------------------------------- + +Rails is smart enough to only execute the migrations that have not already been run against this particular database. === Associating Models +Active Record associations let you declaratively quantify the relationship between two models. In the case of comments and posts, you could write out the relationships this way: + +* Each comment belongs to one post +* One post can have many comments + +In fact, this is very close to the syntax that Rails uses to declare this association. You've already seen the line of code inside the Comment model that makes each comment belong to a Post: + +[source, ruby] +------------------------------------------------------- +class Comment < ActiveRecord::Base + belongs_to :post +end +------------------------------------------------------- + +You'll need to edit the +post.rb+ file to add the other side of the association: + +[source, ruby] +------------------------------------------------------- +class Post < ActiveRecord::Base + has_many :comments +end +------------------------------------------------------- + +These two declarations enable a good bit of automatic behavior. For example, if you have an instance variable +@post+ containing a post, you can retrieve all the comments belonging to that post as the array +@post.comments+. + +TIP: For more information on Active Record associations, see the link:../activerecord/association_basics.html+[Active Record Associations] guide. + +=== Adding a Route + +_Routes_ are entries in the +config/routes.rb+ file that tell Rails how to match incoming HTTP requests to controller actions. Open up that file and find the existing line referring to +posts+. Then edit it as follows: + +[source, ruby] +------------------------------------------------------- +map.resources :posts do |post| + post.resources :comments +end +------------------------------------------------------- + +This creates +comments+ as a _nested resource_ within +posts+. This is another part of capturing the hierarchical relationship that exists between posts and comments. + +TIP: For more information on routing, see the link:../routing/routing_outside_in[Rails Routing from the Outside In] guide. + === Generating a Controller +With the model in hand, you can turn your attention to creating a matching controller. Again, there's a generator for this: + +[source, shell] +------------------------------------------------------- +script/generate controller Comments index show new edit +------------------------------------------------------- + +This creates seven files: + +* +app/controllers/comments_controller.rb+ - The controller +* +app/helpers/comments_helper.rb - A view helper file +* +app/views/comments/index.html.erb - The view for the index action +* +app/views/comments/show.html.erb - The view for the show action +* +app/views/comments/new.html.erb - The view for the new action +* +app/views/comments/edit.html.erb - The view for the edit action +* +test/functional/comments_controller_test.rb - The functional tests for the controller + +The controller will be generated with empty methods for each action that you specified in the call to +script/generate controller+: + +[source, ruby] +------------------------------------------------------- +class CommentsController < ApplicationController + def index + end + + def show + end + + def new + end + + def edit + end + +end +------------------------------------------------------- + +You'll need to flesh this out with code to actually process requests appropriately in each method. Here's a version that (for simplicity's sake) only responds to requests that require HTML: + +[source, ruby] +------------------------------------------------------- +class CommentsController < ApplicationController + def index + @post = Post.find(params[:post_id]) + @comments = @post.comments + end + + def show + @post = Post.find(params[:post_id]) + @comment = Comment.find(params[:id]) + end + + def new + @post = Post.find(params[:post_id]) + @comment = @post.comments.build + end + + def create + @post = Post.find(params[:post_id]) + @comment = @post.comments.build(params[:comment]) + if @comment.save + redirect_to post_comment_path(@post, @comment) + else + render :action => "new" + end + end + + def edit + @post = Post.find(params[:post_id]) + @comment = Comment.find(params[:id]) + end + + def update + @post = Post.find(params[:post_id]) + @comment = Comment.find(params[:id]) + if @comment.update_attributes(params[:comment]) + redirect_to post_comment_path(@post, @comment) + else + render :action => "edit" + end + end + +end +------------------------------------------------------- + +You'll see a bit more complexity here than you did in the controller for posts. That's a side-effect of the nesting that you've set up; each request for a comment has to keep track of the post to which the comment is attached. + === Building Views +Because you skipped scaffolding, you'll need to build views for comments "by hand." Invoking +script/generate controller+ will give you skeleton views, but they'll be devoid of actual content. Here's a first pass at fleshing out the comment views. + +The +index.html.erb+ view: + +[source, ruby] +------------------------------------------------------- +

Comments for <%= @post.title %>

+ + + + + + + +<% for comment in @comments %> + + + + + + + +<% end %> +
CommenterBody
<%=h comment.commenter %><%=h comment.body %><%= link_to 'Show', post_comment_path(@post, comment) %><%= link_to 'Edit', edit_post_comment_path(@post, comment) %><%= link_to 'Destroy', post_comment_path(@post, comment), :confirm => 'Are you sure?', :method => :delete %>
+ +
+ +<%= link_to 'New comment', new_post_comment_path(@post) %> +<%= link_to 'Back to Post', @post %> +------------------------------------------------------- + +The +new.html.erb+ view: + +[source, ruby] +------------------------------------------------------- +

New comment

+ +<% form_for([@post, @comment]) do |f| %> + <%= f.error_messages %> + +

+ <%= f.label :commenter %>
+ <%= f.text_field :commenter %> +

+

+ <%= f.label :body %>
+ <%= f.text_area :body %> +

+

+ <%= f.submit "Create" %> +

+<% end %> + +<%= link_to 'Back', post_comments_path(@post) %> +------------------------------------------------------- + +The +show.html.erb+ view: + +[source, ruby] +------------------------------------------------------- +

Comment on <%= @post.title %>

+ +

+ Commenter: + <%=h @comment.commenter %> +

+ +

+ Comment: + <%=h @comment.body %> +

+ +<%= link_to 'Edit', edit_post_comment_path(@post, @comment) %> | +<%= link_to 'Back', post_comments_path(@post) %> +------------------------------------------------------- + +The +edit.html.erb+ view: + +[source, ruby] +------------------------------------------------------- +

Editing comment

+ +<% form_for([@post, @comment]) do |f| %> + <%= f.error_messages %> + +

+ <%= f.label :commenter %>
+ <%= f.text_field :commenter %> +

+

+ <%= f.label :body %>
+ <%= f.text_area :body %> +

+

+ <%= f.submit "Update" %> +

+<% end %> + +<%= link_to 'Show', post_comment_path(@post, @comment) %> | +<%= link_to 'Back', post_comments_path(@post) %> +------------------------------------------------------- + +Again, the added complexity here (compared to the views you saw for managing comments) comes from the necessity of juggling a post and its comments at the same time. + +=== Hooking Comments to Posts + +As a final step, I'll modify the +show.html.erb+ view for a post to show the comments on that post, and to allow managing those comments: + +[source, ruby] +------------------------------------------------------- +

+ Name: + <%=h @post.name %> +

+ +

+ Title: + <%=h @post.title %> +

+ +

+ Content: + <%=h @post.content %> +

+ +

Comments

+<% @post.comments.each do |c| %> +

+ Commenter: + <%=h c.commenter %> +

+ +

+ Comment: + <%=h c.body %> +

+<% end %> + +<%= link_to 'Edit', edit_post_path(@post) %> | +<%= link_to 'Back', posts_path %> +<%= link_to 'Manage Comments', post_comments_path(@post) %> +------------------------------------------------------- + +Note that each post has its own individual comments collection, accessible as +@post.comments+. That's a consequence of the declarative associations in the models. Path helpers such as +post_comments_path+ come from the nested route declaration in +config/routes.rb+. + == What's Next? Now that you've seen your first Rails application, you should feel free to update it and experiment on your own. But you don't have to do everything without help. As you need assistance getting up and running with Rails, feel free to consult these support resources: @@ -387,6 +905,7 @@ Now that you've seen your first Rails application, you should feel free to updat http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/2[Lighthouse ticket] +* October 13, 2008: First complete draft by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) * October 12, 2008: More detail, rearrangement, editing by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) * September 8, 2008: initial version by James Miller (not yet approved for publication) -- cgit v1.2.3 From 7f744244e120ace985c85ec738da337f88f4f6f0 Mon Sep 17 00:00:00 2001 From: Mike Gunderloy Date: Thu, 16 Oct 2008 07:01:35 -0500 Subject: Revised draft of Getting Started guide. --- .../getting_started_with_rails.txt | 260 ++++++++++++++++++--- 1 file changed, 223 insertions(+), 37 deletions(-) (limited to 'railties/doc/guides/getting_started_with_rails') diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt index 88f99e73c7..5cc3db2748 100644 --- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt +++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt @@ -16,7 +16,10 @@ This guide is designed for beginners who want to get started with a Rails applic * The link:http://rubyforge.org/frs/?group_id=126[RubyGems] packaging system * A working installation of link:http://www.sqlite.org/[SQLite] (preferred), link:http://www.mysql.com/[MySQL], or link:http://www.postgresql.org/[PostgreSQL] -It is highly recommended that you *familiarize yourself with Ruby before diving into Rails*. You will find it much easier to follow what's going on with a Rails application if you understand basic Ruby syntax. Rails isn't going to magically revolutionize the way you write web applications if you have no experience with the language it uses. +It is highly recommended that you *familiarize yourself with Ruby before diving into Rails*. You will find it much easier to follow what's going on with a Rails application if you understand basic Ruby syntax. Rails isn't going to magically revolutionize the way you write web applications if you have no experience with the language it uses. There are some good free resources on the net for learning Ruby, including: + +* link:http://www.rubycentral.com/book/[Programming Ruby] +* link:http://poignantguide.net/ruby/[Why's (Poignant) Guide to Ruby] == What is Rails? @@ -30,7 +33,8 @@ The Rails philosophy includes several guiding principles: * Convention Over Configuration - means that Rails makes assumptions about what you want to do and how you're going to do it, rather than letting you tweak every little thing through endless configuration files. * REST is the best pattern for web applications - organizing your application around resources and standard HTTP verbs is the fastest way to go. -=== Models, Views, and Controllers +=== The MVC Architecture + Rails is organized around the Model, View, Controller architecture, usually just called MVC. MVC benefits include: * Isolation of business logic from the user interface @@ -49,9 +53,49 @@ Views represent the user interface of your application. In Rails, views are ofte Controllers provide the "glue" between models and views. In Rails, controllers are responsible for processing the incoming requests from the web browser, interrogating the models for data, and passing that data on to the views for presentation. +=== The Components of Rails + +Rails provides a full stack of components for creating web applications, including: + +* Action Controller +* Action View +* Active Record +* Action Mailer +* Active Resource +* Railties +* Active Support + +==== Action Controller + +Action Controller is the component that manages the controllers in a Rails application. The Action Controller framework processes incoming requests to a Rails application, extracts parameters, and dispatches them to the intended action. Services provided by Action Controller include session management, template rendering, and redirect management. + +==== Action View + +Action View manages the views of your Rails application. It can create both HTML and XML output by default. Action View manages rendering templates, including nested and partial templates, and includes built-in AJAX support. + +==== Active Record + +Active Record is the base for the models in a Rails application. It provides database independence, basic CRUD functionality, advanced finding capabilities, and the ability to relate models to one another, among other services. + +==== Action Mailer + +Action Mailer is a framework for building e-mail services. You can use Action Mailer to send emails based on flexible templates, or to receive and process incoming email. + +==== Active Resource + +Active Resource provides a framework for managing the connection between business objects an RESTful web services. It implements a way to map web-based resources to local objects with CRUD semantics. + +==== Railties + +Railties is the core Rails code that builds new Rails applications and glues the various frameworks together in any Rails application. + +==== Active Support + +Active Support is an extensive collection of utility classes and standard Ruby library extensions that are used in the Rails, both by the core code and by your applications. + === REST -The foundation of RESTful routing is generally considered to be Roy Fielding's doctoral thesis, link:http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm[Architectural Styles and the Design of Network-based Software Architectures]. Fortunately, you need not read this entire document to understand how REST works in Rails. REST, an acronym for Representational State Transfer, boils down to two main principles for our purposes: +The foundation of the RESTful architecture is generally considered to be Roy Fielding's doctoral thesis, link:http://www.ics.uci.edu/~fielding/pubs/dissertation/top.htm[Architectural Styles and the Design of Network-based Software Architectures]. Fortunately, you need not read this entire document to understand how REST works in Rails. REST, an acronym for Representational State Transfer, boils down to two main principles for our purposes: * Using resource identifiers (which, for the purposes of discussion, you can think of as URLs) to represent resources * Transferring representations of the state of that resource between system components. @@ -72,7 +116,7 @@ In most cases, the easiest way to install Rails is to take advantage of RubyGems [source, shell] ------------------------------------------------------- -gem install rails +$ gem install rails ------------------------------------------------------- NOTE: There are some special circumstances in which you might want to use an alternate installation strategy: @@ -86,21 +130,21 @@ Open a terminal, navigate to a folder where you have rights to create files, and [source, shell] ------------------------------------------------------- -rails blog +$ rails blog ------------------------------------------------------- This will create a Rails application that uses a SQLite database for data storage. If you prefer to use MySQL, run this command instead: [source, shell] ------------------------------------------------------- -rails blog -d mysql +$ rails blog -d mysql ------------------------------------------------------- And if you're using PostgreSQL for data storage, run this command: [source, shell] ------------------------------------------------------- -rails blog -d postgresql +$ rails blog -d postgresql ------------------------------------------------------- In any case, Rails will create a folder in your working directory called +blog+. Open up that folder and explore its contents. Most of the work in this tutorial will happen in the +app/+ folder, but here's a basic rundown on the function of each folder that Rails creates in a new application by default: @@ -121,20 +165,23 @@ File/Folder Purpose +script/+ Scripts provided by Rails to do recurring tasks, such as benchmarking, plugin installation, and starting the console or the web server. +test/+ Unit tests, fixtures, and other test apparatus. These are covered in link:../testing_rails_applications/testing_rails_applications.html[Testing Rails Applications] +tmp/+ Temporary files -+vendor/+ The Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality. ++vendor/+ A place for third-party code. In a typical Rails application, this includes Ruby Gems, the Rails source code (if you install it into your project) and plugins containing additional prepackaged functionality. ------------------------------------------------------------------------------------------------------------------------------------------- -=== Configuring a SQLite Database - -Rails comes with built-in support for SQLite, which is a lightweight flat-file based database application. While a busy production environment may overload SQLite, it works well for development and testing. Rails defaults to using a SQLite database when creating a new project, but you can always change it later. +=== Configuring a Database -If you open the file +config/database.yml+ you'll see a default database configuration using SQLite. The file contains sections for three different environments in which Rails can run by default: +Just about every Rails application will interact with a database. The database to use is specified in a configuration file, +config/database.yml+. +If you open this file in a new Rails application, you'll see a default database configuration using SQLite. The file contains sections for three different environments in which Rails can run by default: * The +development+ environment is used on your development computer as you interact manually with the application * The +test+ environment is used to run automated tests * The +production+ environment is used when you deploy your application for the world to use. -Here's the section of the configuration file with connection information for the development environment: +==== Configuring a SQLite Database + +Rails comes with built-in support for SQLite, which is a lightweight flat-file based database application. While a busy production environment may overload SQLite, it works well for development and testing. Rails defaults to using a SQLite database when creating a new project, but you can always change it later. + +Here's the section of the default configuration file with connection information for the development environment: [source, ruby] ------------------------------------------------------- @@ -150,10 +197,10 @@ If you're not running OS X 10.5 or greater, you'll need to install the SQLite ge [source, shell] ------------------------------------------------------- -gem install sqlite3-ruby +$ gem install sqlite3-ruby ------------------------------------------------------- -=== Configuring a MySQL Database +==== Configuring a MySQL Database If you choose to use MySQL, your +config/database.yml+ will look a little different. Here's the development section: @@ -169,7 +216,7 @@ development: ------------------------------------------------------- If your development computer's MySQL installation includes a root user with an empty password, this configuration should work for you. Otherwise, change the username and password in the +development+ section as appropriate. -=== Configuring a PostgreSQL Database +==== Configuring a PostgreSQL Database If you choose to use PostgreSQL, your +config/database.yml+ will be customized to use PostgreSQL databases: @@ -185,21 +232,86 @@ development: Change the username and password in the +development+ section as appropriate. +== Hello, Rails! + +One of the traditional places to start with a new language is by getting some text up on screen quickly. To do that in Rails, you need to create at minimum a controller and a view. Fortunately, you can do that in a single command. Enter this command in your terminal: + +[source, shell] +------------------------------------------------------- +$ script/generate controller home index +------------------------------------------------------- + +TIP: If you're on Windows, or your Ruby is set up in some non-standard fashion, you may need to explicitly pass Rails +script+ commands to Ruby: +ruby script/generate controller home index+. + +Rails will create several files for you, including +app/views/home/index.html.erb+. This is the template that will be used to display the results of the +index+ action (method) in the +home+ controller. Open this file in your text editor and edit it to contain a single line of code: + +[source, html] +------------------------------------------------------- +

Hello, Rails!

+------------------------------------------------------- + +=== Starting up the Web Server + +You actually have a functional Rails application already - after running only two commands! To see it, you need to start a web server on your development machine. You can do this by running another command: + +[source, shell] +------------------------------------------------------- +$ script/server +------------------------------------------------------- + +This will fire up the lightweight Webrick web server by default. To see your application in action, open a browser window and navigate to +http://localhost:3000+. You should see Rails' default information page: + +image:images/rails_welcome.png[Welcome Aboard screenshot] + +TIP: To stop the web server, hit Ctrl+C in the terminal window where it's running. In development mode, Rails does not generally require you to stop the server; changes you make in files will be automatically picked up by the server. + +The "Welcome Aboard" page is the smoke test for a new Rails application: it makes sure that you have your software configured correctly enough to serve a page. To view the page you just created, navigate to +http://localhost:3000/home/index+. + +=== Setting the Application Home Page + +You'd probably like to replace the "Welcome Aboard" page with your own application's home page. The first step to doing this is to delete the default page from your application: + +[source, shell] +------------------------------------------------------- +$ rm public/index.html +------------------------------------------------------- + +Now, you have to tell Rails where your actual home page is located. Open the file +config/routes.rb+ in your editor. This is your application's, _routing file_, which holds entries in a special DSL (domain-specific language) that tells Rails how to connect incoming requests to controllers and actions. At the bottom of the file you'll see the _default routes_: + +[source, ruby] +------------------------------------------------------- +map.connect ':controller/:action/:id' +map.connect ':controller/:action/:id.:format' +------------------------------------------------------- + +The default routes handle simple requests such as +/home/index+: Rails translates that into a call to the +index+ action in the +home+ controller. As another example, +/posts/edit/1+ would run the +edit+ action in the +posts+ controller with an +id+ of 1. + +To hook up your home page, you need to add another line to the routing file, above the default routes: + +[source, ruby] +------------------------------------------------------- +map.root :controller => "home" +------------------------------------------------------- + +This line illustrates one tiny bit of the "convention over configuration" approach: if you don't specify an action, Rails assumes the +index+ action. + +Now if you navigate to +http://localhost:3000+ in your browser, you'll see the +home/index+ view. + +NOTE: For more information about routing, refer to link:../routing/routing_outside_in.html[Rails Routing from the Outside In]. + == Getting Up and Running Quickly With Scaffolding Rails _scaffolding_ is a quick way to generate some of the major pieces of an application. If you want to create the models, views, and controllers for a new resource in a single operation, scaffolding is the tool for the job. == Creating a Resource -In the case of the blog application, I'll start by generating a scaffolded Post resource: this will represent a single blog posting. To do this, enter this command in your terminal: +In the case of the blog application, you can start by generating a scaffolded Post resource: this will represent a single blog posting. To do this, enter this command in your terminal: [source, shell] ------------------------------------------------------- -script/generate scaffold Post name:string title:string content:text +$ script/generate scaffold Post name:string title:string content:text ------------------------------------------------------- -TIP: If you're on Windows, or your Ruby is set up in some non-standard fashion, you may need to explicitly pass Rails +script+ commands to Ruby: +ruby script/generate scaffold Post name:string title:string content:text+. - NOTE: While scaffolding will get you up and running quickly, the "one size fits all" code that it generates is unlikely to be a perfect fit for your application. In most cases, you'll need to customize the generated code. Many experienced Rails developers avoid scaffolding entirely, preferring to write all or most of their source code from scratch. The scaffold generator will build 13 files in your application, along with some folders, and edit one more. Here's a quick overview of what it creates: @@ -255,33 +367,35 @@ At this point, you need to do two things: create the database and run the migrat [source, shell] ------------------------------------------------------- -rake db:create -rake db:migrate +$ rake db:create +$ rake db:migrate ------------------------------------------------------- NOTE: Because you're working in the development environment by default, both of these commands will apply to the database defined in the +development+ section of your +config/database.yml+ file. -=== Starting the Web Server +=== Adding a Link -You actually have a pretty functional Rails application already - after running only four commands! To see it, you need to start a web server on your development machine. You can do this by running another command: +To hook the posts up to the home page you've already created, you can add a link to the home page. Open +/app/views/home/index.html.erb+ and modify it as follows: -[source, shell] +[source, ruby] ------------------------------------------------------- -script/server +

Hello, Rails!

+ +<%= link_to "My Blog", posts_path %> ------------------------------------------------------- -This will fire up the lightweight Webrick web server by default. To see your application in action, open a browser window and navigate to +http://localhost:3000+. You should see Rails' default information page: +The +link_to+ method is one of Rails' built-in view helpers. It creates a hyperlink based on text to display and where to go - in this case, to the path for posts. -image:images/rails_welcome.png[Welcome Aboard screenshot] +=== Working with Posts in the Browser -TIP: To stop the web server, hit Ctrl+C in the terminal window where it's running. In development mode, Rails does not generally require you to stop the server; changes you make in files will be automatically picked up by the server. - -The "Welcome Aboard" page is the smoke test for a new Rails application: it makes sure that you have your software configured correctly enough to serve a page. But you probably wanted to see something about posts. To do that, navigate to +http://localhost:3000/posts+: +Now you're ready to start working with posts. To do that, navigate to +http://localhost:3000+ and then click the "My Blog" link: image:images/posts_index.png[Posts Index screenshot] This is the result of Rails rendering the +index+ view of your posts. There aren't currently any posts in the database, but if you click the +New Post+ link you can create one. After that, you'll find that you can edit posts, look at their details, or destroy them. All of the logic and HTML to handle this was built by the single +script/generate scaffold+ command. +TIP: In development mode (which is what you're working in by default), Rails reloads your application with every browser request, so there's no need to stop and restart the web server. + Congratulations, you're riding the rails! Now it's time to see how it all works. === The Model @@ -296,6 +410,50 @@ end There isn't much to this file - but note that the +Post+ class inherits from +ActiveRecord::Base+. Active Record supplies a great deal of functionality to your Rails models for free, including basic database CRUD (Create, Read, Update, Destroy) operations, data validation, as well as sophisticated search support and the ability to relate multiple models to one another. +=== Adding Some Validation + +Rails includes methods to help you validate the data that you send to models. Open the +app/models/post.rb+ file and edit it: + +[source, ruby] +------------------------------------------------------- +class Comment < ActiveRecord::Base + belongs_to :post + validates_presence_of :commenter, :body + validates_length_of :commenter, :minimum => 5 +end +------------------------------------------------------- + +These changes will ensure that all comments have a body and a commenter, and that the commenter is at least five characters long. Rails can validate a variety of conditions in a model, including the presence or uniqueness of columns, their format, and the existence of associated objects. + +=== Using the Console + +To see your validations in action, you can use the console. The console is a command-line tool that lets you execute Ruby code in the context of your application: + +[source, shell] +------------------------------------------------------- +$ script/console +------------------------------------------------------- + +After the console loads, you can use it to work with your application's models: + +[source, shell] +------------------------------------------------------- +>> c = Comment.create(:body => "A new comment") +=> # +>> c.save +=> false +>> c.errors +=> #, @errors={"commenter"=>["can't be blank", +"is too short (minimum is 5 characters)"]}> +------------------------------------------------------- + +This code shows creating a new +Comment+ instance, attempting to save it and getting +false+ for a return value (indicating that the save failed), and inspecting the +errors+ of the comment. + +TIP: Unlike the development web server, the console does not automatically load your code afresh for each line. If you make changes, type +reload!+ at the console prompt to load them. + === Listing All Posts The easiest place to start looking at functionality is with the code that lists all posts. Open the file +app/controllers/posts_controller.rb + and look at the +index+ action: @@ -350,10 +508,37 @@ This view iterates over the contents of the +@posts+ array to display content an * +h+ is a Rails helper method to sanitize displayed data, preventing cross-site scripting attacks * +link_to+ builds a hyperlink to a particular destination -* +edit_post_path+ is a helper that Rails provides as part of RESTful routing. +* +edit_post_path+ is a helper that Rails provides as part of RESTful routing. You’ll see a variety of these helpers for the different actions that the controller includes. TIP: For more details on the rendering process, see link:../actionview/layouts_and_rendering [Layouts and Rendering in Rails]. +=== Customizing the Layout + +The view is only part of the story of how HTML is displayed in your web browser. Rails also has the concept of +layouts+, which are containers for views. When Rails renders a view to the browser, it does so by putting the view's HTML into a layout's HTML. The +script/generate scaffold+ command automatically created a default layout, +app/views/layouts/posts.html.erb+, for the posts. Open this layout in your editor and modify the +body+ tag: + +[source, ruby] +------------------------------------------------------- + + + + + + Posts: <%= controller.action_name %> + <%= stylesheet_link_tag 'scaffold' %> + + + +

<%= flash[:notice] %>

+ +<%= yield %> + + + +------------------------------------------------------- + +Now when you refresh the +/posts+ page, you'll see a gray background to the page. This same gray background will be used throughout all the views for posts. + === Creating New Posts Creating a new post involves two actions. The first is the +new+ action, which instantiates an empty +Post+ object: @@ -399,7 +584,7 @@ The +new.html.erb+ view displays this empty Post to the user: <%= link_to 'Back', posts_path %> ------------------------------------------------------- -The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed. +The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed. Rails uses +form_for+ in preference to having your write raw HTML because the code is more succinct, and because it explicitly ties the form to a particular model instance. When the user clicks the +Create+ button on this form, the browser will send information back to the +create+ method of the controller (Rails knows to call the +create+ method because the form is sent with an HTTP POST request; that's one of the conventions that I mentioned earlier): @@ -531,7 +716,7 @@ end In the +update+ action, Rails first uses the +:id+ parameter passed back from the edit view to locate the database record that's being edited. The +update_attributes+ call then takes the rest of the parameters from the request and applies them to this record. If all goes well, the user is redirected to the post's +show+ view. If there are any problems, it's back to +edit+ to correct them. -NOTE: Sharp-eyed readers will have noticed that the +form_for+ declaration is identical for the +create+ and +edit+ views. Rails generates different code for the two forms because it's smart enough to notice that in the one case it's being passed a new record that has never been saved, and in the other case an existing record that has already been saved to the database. +NOTE: Sharp-eyed readers will have noticed that the +form_for+ declaration is identical for the +create+ and +edit+ views. Rails generates different code for the two forms because it's smart enough to notice that in the one case it's being passed a new record that has never been saved, and in the other case an existing record that has already been saved to the database. In a production Rails application, you would ordinarily eliminate this duplication by moving identical code to a _partial template_, which you could then include in both parent templates. But the scaffold generator tries not to make too many assumptions, and generates code that’s easy to modify if you want different forms for +create+ and +edit+. === Destroying a Post @@ -562,7 +747,7 @@ Models in Rails use a singular name, and their corresponding database tables use [source, shell] ------------------------------------------------------- -script/generate model Comment commenter:string body:text post:references +$ script/generate model Comment commenter:string body:text post:references ------------------------------------------------------- This command will generate four files: @@ -607,7 +792,7 @@ The +t.references+ line sets up a foreign key column for the association between [source, shell] ------------------------------------------------------- -rake db:migrate +$ rake db:migrate ------------------------------------------------------- Rails is smart enough to only execute the migrations that have not already been run against this particular database. @@ -662,7 +847,7 @@ With the model in hand, you can turn your attention to creating a matching contr [source, shell] ------------------------------------------------------- -script/generate controller Comments index show new edit +$ script/generate controller Comments index show new edit ------------------------------------------------------- This creates seven files: @@ -905,6 +1090,7 @@ Now that you've seen your first Rails application, you should feel free to updat http://rails.lighthouseapp.com/projects/16213-rails-guides/tickets/2[Lighthouse ticket] +* October 16, 2008: Revised based on feedback from Pratik Naik by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) * October 13, 2008: First complete draft by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) * October 12, 2008: More detail, rearrangement, editing by link:../authors.html#mgunderloy[Mike Gunderloy] (not yet approved for publication) * September 8, 2008: initial version by James Miller (not yet approved for publication) -- cgit v1.2.3 From 9d270e4b99ae0cd74ac814a0bad72e4427155ddf Mon Sep 17 00:00:00 2001 From: Mike Gunderloy Date: Thu, 16 Oct 2008 07:05:50 -0500 Subject: Minor formatting change in Getting Started guide. --- .../guides/getting_started_with_rails/getting_started_with_rails.txt | 3 --- 1 file changed, 3 deletions(-) (limited to 'railties/doc/guides/getting_started_with_rails') diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt index 5cc3db2748..0098f1d225 100644 --- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt +++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt @@ -608,10 +608,7 @@ end The +create+ action instantiates a new Post object from the data supplied by the user on the form, which Rails makes available in the +params+ hash. After saving the new post, it uses +flash[:notice]+ to create an informational message for the user, and redirects to the show action for the post. If there's any problem, the +create+ action just shows the +new+ view a second time, with any error messages. -.The Flash -************************************************************************************************************** Rails provides the +flash+ hash (usually just called the Flash) so that messages can be carried over to another action, providing the user with useful information on the status of their request. In the case of +create+, the user never actually sees any page rendered during the Post creation process, because it immediately redirects to the new Post as soon Rails saves the record. The Flash carries over a message to the next action, so that when the user is redirected back to the +show+ action, they are presented with a message saying "Post was successfully created." -************************************************************************************************************** === Showing an Individual Post -- cgit v1.2.3 From 5c90c988f81b3ca3bfe74ce413c882ce9f17d501 Mon Sep 17 00:00:00 2001 From: Mike Gunderloy Date: Thu, 16 Oct 2008 10:40:58 -0500 Subject: A few updates to Getting Started guide --- .../getting_started_with_rails/getting_started_with_rails.txt | 7 +++++-- 1 file changed, 5 insertions(+), 2 deletions(-) (limited to 'railties/doc/guides/getting_started_with_rails') diff --git a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt index 0098f1d225..b6d8203c8b 100644 --- a/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt +++ b/railties/doc/guides/getting_started_with_rails/getting_started_with_rails.txt @@ -18,6 +18,7 @@ This guide is designed for beginners who want to get started with a Rails applic It is highly recommended that you *familiarize yourself with Ruby before diving into Rails*. You will find it much easier to follow what's going on with a Rails application if you understand basic Ruby syntax. Rails isn't going to magically revolutionize the way you write web applications if you have no experience with the language it uses. There are some good free resources on the net for learning Ruby, including: +* link:http://www.humblelittlerubybook.com/[Mr. Neigborly’s Humble Little Ruby Book] * link:http://www.rubycentral.com/book/[Programming Ruby] * link:http://poignantguide.net/ruby/[Why's (Poignant) Guide to Ruby] @@ -510,7 +511,7 @@ This view iterates over the contents of the +@posts+ array to display content an * +link_to+ builds a hyperlink to a particular destination * +edit_post_path+ is a helper that Rails provides as part of RESTful routing. You’ll see a variety of these helpers for the different actions that the controller includes. -TIP: For more details on the rendering process, see link:../actionview/layouts_and_rendering [Layouts and Rendering in Rails]. +TIP: For more details on the rendering process, see link:../actionview/layouts_and_rendering.html[Layouts and Rendering in Rails]. === Customizing the Layout @@ -584,7 +585,9 @@ The +new.html.erb+ view displays this empty Post to the user: <%= link_to 'Back', posts_path %> ------------------------------------------------------- -The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed. Rails uses +form_for+ in preference to having your write raw HTML because the code is more succinct, and because it explicitly ties the form to a particular model instance. +The +form_for+ block is used to create an HTML form. Within this block, you have access to methods to build various controls on the form. For example, +f.text_field :name+ tells Rails to create a text input on the form, and to hook it up to the +name+ attribute of the instance being displayed. You can only use these methods with attributes of the model that the form is based on (in this case +name+, +title+, and +content+). Rails uses +form_for+ in preference to having your write raw HTML because the code is more succinct, and because it explicitly ties the form to a particular model instance. + +TIP: If you need to create an HTML form that displays arbitrary fields, not tied to a model, you should use the +form_tag+ method, which provides shortcuts for building forms that are not necessarily tied to a model instance. When the user clicks the +Create+ button on this form, the browser will send information back to the +create+ method of the controller (Rails knows to call the +create+ method because the form is sent with an HTTP POST request; that's one of the conventions that I mentioned earlier): -- cgit v1.2.3