The Rails 4 Way: 实战指南（2013年最新版）

需积分: 9 33 浏览量更新于2024-07-20 收藏 3.61MB PDF 举报

"The Rails 4 Way" 是由 Obie Fernandez、Kevin Faustino、Vitaly Kushner 和 Ari Lerner 联合撰写的英文版书籍，专为Ruby on Rails框架的学习者和开发者设计。该书出版于2013年8月14日，采用Lean Publishing模式，这意味着它是一个不断迭代、根据读者反馈进行改进的电子书。通过轻量级工具和多次修订，作者旨在确保提供最新、最实用的Rails 4指南。作为Ruby on Rails框架的权威资源，这本书详尽地介绍了如何高效地利用Rails 4进行Web应用程序开发。书中内容涵盖了广泛的主题，包括但不限于： 1. 引言：概述了Rails 4在Web开发中的地位，强调其敏捷开发能力以及与其他技术的比较优势。 2. 目标：明确阐述了读者学习本书后应掌握的核心技能，如MVC（模型-视图-控制器）架构、路由、数据库集成、测试驱动开发等。 3. 预备知识：对读者的背景有一定要求，建议读者对Ruby语言基础和基本的Web开发概念有了解。 4. 所需技术：强调读者在开始阅读前需要安装的Rails环境，包括Ruby、RubyGems、版本管理工具（如Git）等。 5. 内容结构：包含了后续章节的概览，可能涉及的主题包括但不限于ActiveRecord ORM、Action Pack、Controllers和Views的创建与操作、RESTful设计原则、部署策略以及持续集成/持续部署（CI/CD）实践。 "The Rails 4 Way"不仅是一本技术指南，还注重实践经验的分享和最佳实践，鼓励读者参与到Rails社区，并利用社交媒体平台如Twitter进行互动，通过hashtag #tr4w进行讨论和推广。通过阅读这本书，开发者可以深入了解Rails 4的最新特性和开发技巧，提高开发效率，进而推动Web应用项目的成功实施。

Introduction

Coming soon.

About This Book

This book is not a tutorial or basic introduction to Ruby or Rails. It is meant as a day-to-day reference for the

full-time Rails developer. The more confident reader might be able to get started in Rails using just this book,

extensive online resources, and his wits, but there are other publications that are more introductory in nature

and might be a wee bit more appropriate for beginners.

Every contributor to this book works with Rails on a full time basis. We do not spend our days writing books

or training other people, although that is certainly something that we enjoy doing on the side.

This book was originally conceived for myself, because I hate having to use online documentation, especially

API docs, which need to be consulted over and over again. Since the API documentation is liberally licensed

(just like the rest of Rails), there are a few sections of the book that reproduce parts of the API documentation.

In practically all cases, the API documentation has been expanded and/or corrected, supplemented with

additional examples and commentary drawn from practical experience.

Hopefully you are like me—I really like books that I can keep next to my keyboard, scribble notes in, and fill

with bookmarks and dog-ears. When I’m coding, I want to be able to quickly refer to both API documentation,

in-depth explanations, and relevant examples.

Book Structure

I attempted to give the material a natural structure while meeting the goal of being the best-possible Rails

reference book. To that end, careful attention has been given to presenting holistic explanations of each

subsystem of Rails, including detailed API information where appropriate. Every chapter is slightly different

in scope, and I suspect that Rails is now too big a topic to cover the whole thing in depth in just one book.

Believe me, it has not been easy coming up with a structure that makes perfect sense for everyone. Particularly,

I have noted surprise in some readers when they notice that Active Record is not covered first. Rails is foremost

a web framework and at least to me, the controller and routing implementation is the most unique, powerful,

and effective feature, with Active Record following a close second.

Sample Code and Listings

The domains chosen for the code samples should be familiar to almost all professional developers. They

include time and expense tracking, auctions, regional data management, and blogging applications. I don’t

spend pages explaining the subtler nuances of the business logic for the samples or justify design decisions

that don’t have a direct relationship to the topic at hand. Following in the footsteps of my series colleague Hal

Fulton and The Ruby Way, most of the snippets are not full code listings—only the relevant code is shown.

Ellipses (…) denote parts of the code that have been eliminated for clarity.

Introduction vi

Whenever a code listing is large and significant, and I suspect that you might want to use it verbatim in your

own code, I supply a listing heading. There are not too many of those. The whole set of code listings will not

add up to a complete working system, nor are there 30 pages of sample application code in an appendix. The

code listings should serve as inspiration for your production-ready work, but keep in mind that it often lacks

touches necessary in real-world work. For example, examples of controller code are often missing pagination

and access control logic, because it would detract from the point being expressed.

Some of the source code for my examples can be found at http://github.com/obie/tr3w_time_and_expenses.

Note that it is not a working nor complete application. It just made sense at times to keep the code in the

context of an application and hopefully you might draw some inspiration from browsing it.

Concerning 3rd-Party RubyGems and Plugins

Whenever you find yourself writing code that feels like plumbing, by which I mean completely unrelated to

the business domain of your application, you’re probably doing too much work. I hope that you have this

book at your side when you encounter that feeling. There is almost always some new part of the Rails API or

a third-party RubyGem for doing exactly what you are trying to do.

As a matter of fact, part of what sets this book apart is that I never hesitate in calling out the availability of

third-party code, and I even document the RubyGems and plugins that I feel are most crucial for effective

Rails work. In cases where 3rd-party code is better than the built-in Rails functionality, we don’t cover the

built-in Rails functionality (pagination is a good example).

An average developer might see his productivity double with Rails, but I’ve seen serious Rails developers

achieve gains that are much, much higher. That’s because we follow the Don’t Repeat Yourself (DRY) principle

religiously, of which Don’t Reinvent The Wheel (DRTW) is a close corollary. Reimplementing something

when an existing implementation is good enough is an unnecessary waste of time that nevertheless can be

very tempting, since it’s such a joy to program in Ruby.

Ruby on Rails is actually a vast ecosystem of core code, official plugins, and third-party plugins. That

ecosystem has been exploding rapidly and provides all the raw technology you need to build even the most

complicated enterprise-class web applications. My goal is to equip you with enough knowledge that you’ll be

able to avoid continuously reinventing the wheel.

Recommended Reading and Resources

Readers may find it useful to read this book while referring to some of the excellent reference titles listed in

this section.

Most Ruby programmers always have their copy of the “Pickaxe” book nearby, Programming Ruby (ISBN:

0-9745140-5-5), because it is a good language reference. Readers interested in really understanding all of the

nuances of Ruby programming should acquire The Ruby Way, Second Edition (ISBN: 0-6723288-4-4).

I highly recommend Peepcode Screencasts, in-depth video presentations on a variety of Rails subjects by the

inimitable Geoffrey Grosenbach, available at http://peepcode.com

Ryan Bates does an excellent job explaining nuances of Rails development in his long-running series of free

webcasts available at http://railscasts.com/

Introduction vii

Regarding David Heinemeier Hansson a.k.a. DHH I had the pleasure of establishing a friendship with David

Heinemeier Hansson, creator of Rails, in early 2005, before Rails hit the mainstream and he became an

International Web 2.0 Superstar. My friendship with David is a big factor in why I’m writing this book today.

David’s opinions and public statements shape the Rails world, which means he gets quoted a lot when we

discuss the nature of Rails and how to use it effectively.

David has told me on a couple of occasions that he hates the “DHH” moniker that people tend to use instead

of his long and difficult-to-spell full name. For that reason, in this book I try to always refer to him as “David”

instead of the ever-tempting “DHH.” When you encounter references to “David” without further qualification,

I’m referring to the one-and-only David Heinemeier Hansson.

There are a number of notable people from the Rails world that are also referred to on a first-name basis in

this book. Those include:

• Yehuda Katz

• Jamis Buck

• Xavier Noria

Goals

As already stated, I hope to make this your primary working reference for Ruby on Rails. I don’t really

expect too many people to read it through end to end unless they’re expanding their basic knowledge of

the Rails framework. Whatever the case may be, over time I hope this book gives you as an application

developer/programmer greater confidence in making design and implementation decisions while working on

your day-to-day tasks. After spending time with this book, your understanding of the fundamental concepts

of Rails coupled with hands-on experience should leave you feeling comfortable working on real-world Rails

projects, with real-world demands.

If you are in an architectural or development lead role, this book is not targeted to you, but should make you

feel more comfortable discussing the pros and cons of Ruby on Rails adoption and ways to extend Rails to

meet the particular needs of the project under your direction.

Finally, if you are a development manager, you should find the practical perspective of the book and our

coverage of testing and tools especially interesting, and hopefully get some insight into why your developers

are so excited about Ruby and Rails.

Prerequisites

The reader is assumed to have the following knowledge:

• Basic Ruby syntax and language constructs such as blocks

• Solid grasp of object-oriented principles and design patterns

• Basic understanding of relational databases and SQL

• Familiarity with how Rails applications are laid out and function

• Basic understanding of network protocols such as HTTP and SMTP

1 Rails Environments and Configuration

[Rails] gained a lot of its focus and appeal because I didn’t try to please people who didn’t share

my problems. Differentiating between production and development was a very real problem for

me, so I solved it the best way I knew how.

—David Heinemeier Hansson

Rails applications are preconfigured with three standard modes of operation: development, test, and pro-

duction. These modes are basically execution environments and have a collection of associated settings that

determine things such as which database to connect to, and whether the classes of your application should be

reloaded with each request. It is also simple to create your own custom environments if necessary.

The current environment can be specified via the environment variable RAILS_ENV, which names the desired

mode of operation and corresponds to an environment definition file in the config/environments folder.

You can also set the environment variable RACK_ENV or as a last resort you may rely on the default being

development. Since this environment setting governs some of the most fundamental aspects of Rails, such as

class loading, in order to really understand the Rails way you should understand its environment settings.

In this chapter, we start by covering Bundler, a tool that manages gem dependencies for your Ruby application.

It takes a gem manifest file and is able to fetch, download, and install the gems in the manifest, and all child

dependencies. Then we move on to how Rails starts up and handles requests, by examining scripts such as

boot.rb and application.rb and the settings that make up the three standard environment settings (modes).

We also cover some of the basics of defining your own environments, and why you might choose to do so.

Note that this book is not written with absolute newcomers to Rails in mind. To make the most out of this

book, you should already be at least somewhat familiar with how to bootstrap a Rails application and the

meaning of M.V.C. If you are not, I recommend that you first take advantage of the excellent Ruby on Rails

Tutorial website¹ by Michael Hartl, another Professional Ruby Series author.

1.1 Bundler

Bundler² is not a technology that is specific to Rails 4, but it is the preferred way to manage your application’s

gem dependencies. Applications generated with Rails 4 use Bundler automatically, and you should not need

to install the bundler gem separately since it’s a dependency of Rails itself.

Since we believe that you should use Bundler, figuring out how to not use Bundler is left as an exercise for

adventurous and/or nonconformist readers.

One of the most important things that Bundler does is dependency resolution on the full list of gems specified

in your configuration, all at once. This differs from the one-at-a-time dependency resolution approach

employed by Rubygems and previous versions of Rails, which can (and often did) result in the following

hard-to-fix problem:

Assume that your system had the following Rubygem versions installed.

¹http://railstutorial.org

²http://gembundler.com

剩余706页未读，继续阅读

布拉格之春

粉丝: 0
资源: 4

The Rails 4 Way: 实战指南（2013年最新版）

The Rails 5 Way(4th) 无水印原版pdf

The Rails 4 Way

The rails4 way

The Rails 4 Way, 3rd edition.pdf

Pragmatic.Rails.Recipes.Rails.3.Edition.Mar.2012.pdf

Beginning Rails 4, 3rd Edition.pdf

Wrox.Professional.Ruby.on.Rails.Feb.2008.pdf

Pragmatic - Agile.Web.Development.with.Rails.4.Sep.2013.pdf

Agile.Web.Development.with.Rails.4(2013.10).Sam.Ruby.文字版.pdf 一书的配套代码

Agile Web Development with Rails, 4th Edition.pdf

最新资源