Shulou(Shulou.com)06/02 Report--

This article focuses on "how to build Rails3 applications", interested friends may wish to take a look. The method introduced in this paper is simple, fast and practical. Now let the editor take you to learn how to build Rails3 applications.

Big changes, small changes

There are too many changes in Rails 3 to list them all here.

◆ can control all events with one command. With Rails 3, instead of using a complete set of scripts (script/server, script/generate, and others) in each application, you can replace its functionality with a single command, which is aptly named rails. For example, where you used to type. / script/console, now you just need to type rails console. The rails command can also generate new applications as before. How it works varies depending on whether it is started in an existing Rails application.

◆ can provide specific solutions for dependencies. Coordinating and resolving gem dependencies is a thorny problem. Like the collection of available gems, the revision of gem varies from system to system. Because of this diversity, it is difficult to deploy or share a Rails application widely. Rails 3 introduces Bundler, a utility dedicated to managing dependencies (so you no longer need to use config.gem). You can declare dependencies in a directory called Gemfile in the application root directory. Bundler downloads and stores all specified gem. You can even "package" gem in your application to prevent downloads from external repositories.

◆ does not have the query function of query statements. For a long time, Rails has been able to make full use of domain-specific languages (DSL)-consider has_one or validates_numericality_of-with one obvious exception: database queries. It's safe to say that Rails's dynamic searcher is convenient and easy to use, but mixing option hashes such as: conditions,: order, and: limit are very common because they are find_by_sql statements. Rails 3 incorporates relational algebra, a DSL specifically designed to represent queries. The basic commands include project (for selecting columns), where (for representing conditions), join (for specifying relationships), take and skip (for qualifying and canceling, respectively), and other attributes such as group (for aggregation).

The controller used to blur the boilerplate code. The core operations of Rails controllers-new, create, edit, and update--are usually the same, especially when most of the controllers are used for CRUD operations. In fact, the output of the controller generator. / script/generate controller generally does not require further modification to meet the needs. Given these similarities, Rails 3 introduces Responder to further simplify the code. For example, here are a few lines of code required for all the create operations:

Class PostsController respond_to: html,: xml def create @ post = Post.create (params [: post]) respond_with (@ post) end end

In this code snippet, if @ post is saved successfully, respond_with (@ post) is sent to show to display the new record, while assuming the object's validation fails, it is sent to new. This is just a small sample. You can find examples of these new features and more in the next section, such as building Rails 3 applications from scratch.

* build Rails 3 application

To run Rails 3, your system must have Ruby version 1.8.7 or Ruby version 1.9.2, or a newer version of the programming language and its additional libraries and interpreters. The Git software version control system is also installed on your machine, because Rails 3 and many other important Rails projects are maintained in Git. Your system also needs a database engine, such as SQLite (version 3), MySQL, or PostgreSQL. A Web server is not required when developing Rails applications, but it is usually part of a production deployment.

To create a Rails 3 application, you must have the Rails 3 pre-release gem and all its related products. At this point, you only need to run a few commands (see listing 1) to install the required components. Please review the Rails 3 documentation before you proceed, as the specific actions will vary from version to version. )

Listing 1. Rails 3 pre-release gem and related products $gem install rails3b Due to a rubygems bug You must uninstall all older versions of bundler for 0.9 to work Successfully installed mime-types-1.16 Successfully installed mail-2.1.2 Successfully installed text-hyphen-1.0.0 Successfully installed text-format-1.0.0 Successfully installed memcache-client-1.7.8 Successfully installed rack-1.1.0 Successfully installed rack-mount-0.4.7 Successfully installed abstract-1.0.0 Successfully installed erubis-2.6.5 Successfully installed i18n-0.3.3 Successfully installed tzinfo-0.3. 16 Successfully installed bundler-0.9.5 Successfully installed thor-0.13.1 Successfully installed rails3b-3.0.1 14 gems installed $gem install arel--pre Successfully installed activesupport-3.0.0.beta Successfully installed arel-0.2.pre 2 gems installed $gem install rails-- pre Successfully installed activemodel-3.0.0.beta Successfully installed actionpack-3.0.0.beta Successfully installed activerecord-3.0.0.beta Successfully installed activeresource-3.0.0.beta Successfully installed actionmailer-3. 0.0.beta Successfully installed railties-3.0.0.beta Successfully installed rails-3.0.0.beta 7 gems installed

The next step is to generate the application-a small wiki is shown in listing 2. The application creates and manages articles. Each article has a title and some prose, and you can create a new article by creating a reference to a new article from the body of an existing page. The reference can be any hump case word, such as TheSolarSystem or TheOscars.

Note: the source code for the wiki application is available through the download table below.

Listing 2. Wiki Rails application $rails wiki

If you run ls-lR to view the contents of the application, some new files will be displayed:

◆ Gemfile, which is the gem list mentioned earlier. The file must contain at least two lines: one pointing to the source of the Rails 3 beta gem and the other binding the Rails 3 beta gem itself. You may also need a third line (at least) to connect to the database:

Source 'http://gemcutter.org' gem "rails", "3.0.0.beta" gem "sqlite3-ruby",: require = > "sqlite3"

◆ config/application.rb, which contains many of the options previously provided in config/environment.rb. Although the latter is still in place, the file is largely no longer used. A significant additional feature of config/application.rb is generators block:

Config.generators do | g | g.orm: active_record g.template_engine: erb g.test_framework: test_unit,: fixture = > true end

Your Rails 3 application can use some compatible object-relational mappers (ORM), template engines, and testing frameworks. The generator block specifies the * items of the application and invokes the appropriate generator based on your model, view, and so on.

◆ db/seeds.rb, which is not new to Rails 3, but needs to be highlighted because it was recently added (introduced in Rails version 2.3.4). If your application needs initial data to work properly, such as an administrative user, price code, or static page, you can create the data in db/seeds.rb and run the task rake db:seed. Before the Seed file, there is no convention for initialization, and many developers put the code in the migration, which tends to confuse the difference between creating and populating the database.

◆ config.ru, which exists in the root directory of each Rails 3 application, is the so-called rackup file, which is the configuration file of the Rack-based application. Rails 3 is a Rack application and is compatible with any Web server that supports Rack. In general, do not change the config.ru file unless you want to add other Rack components.

There are some other new files; however, most of them look similar to Rails version 2.3. The function of config/routes.rb file is the same as before, except that it is more simplified and has the characteristics of Ruby. You will see an example soon.

After you build the application and edit the Gemfile to declare the dependencies, the next step is to collect the gem required by the application. This is done by the new utility bundle (see listing 3).

Listing 3. Collect the required gem $bundle installFetching source index from http://gemcutter.org Resolving dependencies Installing abstract (1.0.0) from system gems Installing actionmailer (3.0.0.beta) from system gems Installing actionpack (3.0.0.beta) from system gems Installing activemodel (3.0.0.beta) from system gems Installing activerecord (3.0.0.beta) from system gems Installing activeresource (3.0.0.beta) from system gems Installing activesupport (3.0.0.beta) from system gems Installing arel ( 0.2.1) from rubygems repository at http://gemcutter.org Installing builder (2.1.2) from system gems Installing bundler (0.9.7) from rubygems repository at http://gemcutter.org Installing erubis (2.6.5) from system gems Installing i18n (0.3.3) from system gems Installing mail (2.1.2) from system gems Installing memcache-client (1.7.8) from system gems Installing mime-types (1.16) from system gems Installing rack (1.1.0) From system gems Installing rack-mount 0.4.7 from system gems Installing rack-test 0.5.3 from system gems Installing rails (3.0.0.beta) from system gems Installing railties (3.0.0.beta) from system gems Installing rake 0.8.7 from system gems Installing sqlite3-ruby 1.2.5 from rubygems repository at http://gemcutter.org with native extensions Installing text-format 1.0.0 from system gems Installing text-hyphen 1.0 .0) from system gems Installing thor (0.13.3) from rubygems repository at http://gemcutter.org Installing tzinfo (0.3.16) from system gems Your bundle is complete!

The bundle utility, or Bundler for short, can be used to download and install all the gem specified in Gemfile and any of these gems dependencies (see listing 4). The bundle utility can also copy all dependencies into your application, making your code base self-sufficient. Specifically, if you run bundle pack,Bundler, all gem data will be copied to vendor/cache.

Listing 4. Run the bundle utility $bundle pack Copying. Gem files into vendor/cache * bundler-0.9.7.gem * thor-0.13.3.gem * abstract-1.0.0.gem * mime-types-1.16.gem * text-hyphen-1.0.0.gem * rack-mount-0.4.7.gem * rake-0.8.7.gem * text-format-1.0.0. Gem * tzinfo-0.3.16.gem * rack-test-0.5.3.gem * builder-2.1.2.gem * erubis-2.6.5.gem * memcache-client-1.7.8.gem * rack-1.1.0.gem * sqlite3-ruby-1.2.5.gem * i18n-0.3.3.gem * activesupport-3.0.0.beta.gem * Arel-0.2.1.gem * mail-2.1.2.gem * activemodel-3.0.0.beta.gem * activerecord-3.0.0.beta.gem * actionpack-3.0.0.beta.gem * railties-3.0.0.beta.gem * actionmailer-3.0.0.beta.gem * activeresource-3.0.0.beta.gem * rails-3.0.0.beta.gem $ls vendor/cache abstract-1.0.0.gem memcache-client-1.7.8.gem actionmailer-3.0.0.beta.gem mime-types-1.16.gem actionpack-3.0.0.beta.gem rack-1.1.0.gem activemodel-3.0.0.beta.gem rack-mount-0.4.7.gem activerecord-3.0.0.beta.gem rack-test-0.5.3.gem activeresource-3.0.0.beta.gem Rails-3.0.0.beta.gem activesupport-3.0.0.beta.gem railties-3.0.0.beta.gem arel-0.2.1.gem rake-0.8.7.gem builder-2.1.2.gem sqlite3-ruby-1.2.5.gem bundler-0.9.7.gem text-format-1.0.0.gem erubis-2.6.5.gem text-hyphen-1.0.0.gem i18n-0.3.3. Gem thor-0.13.3.gem mail-2.1.2.gem tzinfo-0.3.16.gem

Think of vendor/cache as the application's own gem repository. You can move the code base anywhere and get the gem software and version you need-without the need for remote memory. For example, if you run bundle install,gem after bundle pack, it will be installed on your system from your application repository (see listing 5).

Listing 5. Install gem Fetching source index from http://gemcutter.org Resolving dependencies Installing abstract (1.0.0) from .gem files at / Users/strike/projects/rails3/wiki/vendor/cache Installing actionmailer (3.0.0.beta) from .gem files at / Users/strike/projects/rails3/wiki/vendor/cache Installing actionpack (3.0.0.beta) from .gem files at / Users/strike/projects/rails3/wiki/vendor/cache. Installing thor (0.13.3) from. Gem files at / Users/strike/projects/rails3/wiki/vendor/cache Installing tzinfo (0.3.16) from. Gem files at / Users/strike/projects/rails3/wiki/vendor/cache Your bundle is complete!

Use wiki

To create an application, you need to generate a working framework (scaffold) for the page, create the database, put the initial page into the database, and set the required path (see listing 6). For simplicity, wiki page records are limited to certain fields: title, header (title acronym), body, and time cut (to record the creation time and * modification time of the page). The title and header are string fields; the prose is the text field; and the time cut is the date and time field. (of course, a real wiki will have other fields, such as the most recent author and the revision history of the page. To keep it as concise as possible, the example also omits users and sessions, formats, and various authentication and authorization. You can use the rails generate scaffold command to generate an initial model, a series of views, and a controller.

Listing 6. Complete wiki application $rails generate scaffold page title:string slug:string body:text-- timestamps invoke active_record create db/migrate/20100221115613_create_pages.rb create app/models/page.rb invoke test_unit create test/unit/page_test.rb create test/fixtures/pages.yml route resources: pages invoke scaffold_controller create app/controllers / pages_controller.rb invoke erb create app/views/pages create app/views/pages/index.html.erb create app/views/pages/edit.html.erb create app/views/pages/show.html.erb create app/views/pages/new.html.erb create app/views/pages/_form.html.erb create app/views/layouts / pages.html.erb invoke test_unit create test/functional/pages_controller_test.rb invoke helper create app/helpers/pages_helper.rb invoke test_unit create test/unit/helpers/pages_helper_test.rb invoke stylesheets create public/stylesheets/scaffold.css

If you want to know how the. / script/generate command has changed, recall that it has been included in the omnipotent rails command. Run rake db:create db:migrate to create the database:

$rake db:create db:migrate = = CreatePages: migrating = =-- create_table (: pages)-> 0.0010s = = CreatePages: migrated (0.0011s) = =

The Wiki already exists, but it is empty. Add an initial page as the benchmark for all other pages. Edit the file db/seeds.rb and write code to create a new page, as shown in listing 7:

Listing 7. Wiki benchmark page Page.create (: title = > 'The Marx Brothers Wiki',: slug = >' Home',: body = >'An encyclopedic guide to the Marx Brothers.')

Run rake db:seed to execute the code. You can verify the page by using a quick browse using rails console, as shown in listing 8.

Listing 8. Verification benchmark page $rake db:seed (in / Users/strike/projects/rails3/wiki) $rails console Loading development environment (Rails 3.0.0.beta) irb (main): 001Users/strike/projects/rails3/wiki 0 > Page.all = > [#]

Please set the path before continuing to run the code. Two paths are required: one default path to find the main page, and the other path to find the page through the header. Listing 9 shows the final version of the config/routes.rb file.

Listing 9. Config/routes.rb (final version) Wiki::Application.routes.draw do | map | resources: pages root: to = > "pages#show" end

In listing 6, the rails generate scaffold page command automatically creates a path on the second line, which is REST-style. You must manually add the path on the third line. The default "root" syntax for specifying the site path is what's new in Rails 3. The third line defines the 'show' method that maps the path' /'to the page controller. The code for the show method looks for the main page in the database and displays it. After adding a new root path, you need to delete the public/index.html file to avoid conflicts:

$rm public/index.html

Now, let's focus on the page controller. The controller code in Rails 3 can be extremely simple. Listing 10 shows the initial implementation of the controller through a single show method.

Listing 10. Rails 3 controller class PagesController

< ApplicationController respond_to :html def show @page = Page.where( :slug =>

(params [: id] | | 'Home') .first respond_with (@ page) end end

As you can see, all the templates that are usually provided in the Rails 2 controller are missing. Respond_to lists the formats supported by the controller; here, it only responds to requests from HTML. Respond_with is a logical shortcut that determines how the controller should proceed.

The syntax of the query is also very different. A query is an example of Rails 3 relational algebra. You may wonder why you need a first suffix. Where and other operands that express the query do not actually cause the query to be executed. In contrast, the query site remains idle until the data is really needed. This is deferred loading, that is, delaying the execution of query statements as long as possible. The first command triggers the actual query in the database.

If you run the application now, you will see something similar to figure 1, and now you can add more code to the controller. Listing 11 shows the complete controller.

Listing 11. Complete Rails 3 controller class PagesController

< ApplicationController respond_to :html before_filter :get_page, :except =>

[: create] def create respond_with (@ page = Page.create (params [: page]) end def edit end def index render: action = >: show end def show @ page | | = Page.new (: slug = > params [: id]) if @ page.new_record? Render: action = >: new else respond_with (@ page) end end def update @ page.update_attributes (params [: page]) respond_with (@ page) end private def get_page @ page = Page.where (: slug = > (params [: id] | | 'Home'). First | | Page.where (: id = > params [: id]). First end end

In this controller, the index method simply reflects the show operation without a page identifier, thus rendering the main page. Show displays a page and provides an ID or header (all operational queries are concentrated in get_page, further reducing the amount of code); if a page does not exist, a new page is prepared for editing. The Page model can only validate all displayed fields:

Class Page > ActiveRecord::Base validates_presence_of: body,: slug,: title end

Converting hump case references to links to other pages is done in the view of the Page model. This is done by the helper function in app/helpers/pages_helper.rb, thus keeping the view to a minimum (see listing 12).

Listing 12. Hump case conversion helper function module PagesHelper def wikify (page) return''if page.body.blank? Page.body.gsub (/ ^) ([Amurz] [[: alnum:]] * ([Amurz] [[: alnum:] *) +) do | match | link_to ($1,: action = >: show,: id = > $1) end end end

This view is typical, as shown in listing 13.

Listing 13. Typical view

Title:b > p >

Body:b > p > |

Raw Operand is a new feature in Rails 3. Unlike previous versions of Rails, all strings can be sent safely (without HTML) by default. If you want to send a string through HTML, you must use raw.

Toggle Rails

In addition to the functional improvements and convenience described here, Rails 3 provides better performance than previous versions, especially when it comes to rendering widgets. You can also create your proprietary validator classes and take full advantage of smoother standard validation. For example, the following validation is written by Jeremy McAnally, requiring four separate lines of code at a time:

Validates: login,: presence = > true,: length = > {: minimum = > 4},: uniqueness = > true,: format = > {: with = > / [A-Za-z0-9] + /} at this point, I believe you have a deeper understanding of "how to build Rails3 applications". You might as well do it in practice! Here is the website, more related content can enter the relevant channels to inquire, follow us, continue to learn!

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.