Rails 3 开发指南：Agile Web Development with Rails 4th Edition

需积分: 9 182 浏览量更新于2024-07-28 收藏 5.67MB PDF 举报

"Agile.Web.Development.with.Rails 4TH.2011.04" 本书《Agile Web Development with Rails》是基于Ruby on Rails框架的第四版，由S. Ruby编写，提供了英文版的最新内容。据描述，这个版本可能在官方网站上需要付费下载。这本书针对的是Rails 3版本，因此对于想要运行书中的示例代码的读者来说，确保安装了正确的Rails版本至关重要。 Rails版本管理与兼容性： Rails的核心团队持续开发和更新Rails框架，新版本可能会引入与先前版本不兼容的变化，这可能会影响到按照旧版本教程编写的应用程序，包括本书中的代码。在开始学习之前，务必按照第一章"Installing Rails"（第24页）中的说明安装正确的Rails版本。检查当前Rails版本，可以在命令行中输入`rails -v`。 Rails更新与本书相关的信息：如果Rails有新的更新和变动影响到本书内容，读者可以参考http://www.pragprog.com/wikis/wiki/ChangesToRails获取详细信息。这是一个官方提供的更新日志，可以帮助读者了解如何适应和解决可能出现的问题。作者与推荐：这本书由Sam、Dave和David共同撰写，受到了Mikel Lindsaar的高度评价。Mikel是Rails核心贡献团队的一员，也是Ruby的创建者之一。他指出，自己当初学习Rails时就是从该书的第一版开始，这本书对初学者理解Rails框架和社区提供了全面的引导，帮助他们开启成功的职业生涯。在阅读了最新版后，他仍然认为它是推荐给新Rails开发者的第一本书。通过这本书，读者可以期待获得关于Rails的全方位理解，包括但不限于Web应用的敏捷开发方法、Rails框架的架构、开发工具的使用、数据库集成、测试策略等。此外，书中还会涵盖最佳实践、社区资源以及如何随着Rails框架的迭代更新来维护和升级现有应用的知识。《Agile Web Development with Rails》第四版是一本详尽的Rails开发指南，不仅适合初学者入门，也对有一定经验的开发者有价值，它能帮助读者跟上Rails框架的最新进展，并掌握高效开发Web应用的技能。

Introduction

Ruby on Rails is a framework that makes it easier to develop, deploy, and

maintain web applications. During the months that followed its initial release,

Rails went from being an unknown toy to being a worldwide phenomenon, and

more important, it has become the framework of choice for the implementation

of a wide range of so-called W e b 2.0 applications.

Why is that?

Rails Simply F e e l s Right

First, a large number of developers were frustrated with the technologies they

were using to create web applications. It didn’t seem to matter whether they

were using Java, PHP, or .NET—there was a growing sense that their job was

just too damn hard. And then, suddenly, along came Rails, and Rails was

easier.

But easy on its own doesn’t cut it. W e ’ r e talking about professional developers

writing real-world websites. They wanted to feel that the applications they

were developing would stand the test of time—that they were designed and

implemented using modern, professional techniques. So, these developers dug

into Rails and discover ed it wasn’t just a tool for hacking out sites.

For example, all Rails applications are implemented using the Model-View-

Controller (MVC) architecture. Java developers are used to frameworks such

as Tapestryand Struts, which are based on MVC. But Rails takes MVC further:

when you develop in Rails, you start with a working application, there’s a

place for each piece of code, and all the pieces of your application interact in a

standard way.

Professional programmers write tests. And again, Rails delivers. All Rails appli-

cations have testing support baked right in. As you add functionality to the

code, Rails automatically creates test stubs for that functionality. The frame-

work makes it easy to test applications, and as a result, Rails applications

tend to get tested.

RAILSSIMPLYFEELSRIGHT 17

Rails applications are written in Ruby, a modern, object-oriented scripting

language. Ruby is concise without being unintelligibly terse—you can express

ideas naturally and cleanly in Ruby code. This leads to programs that are easy

to write and (just as important) are easy to read months later.

Rails takes Ruby to the limit, extending it in novel ways that make a pro-

grammer’s life easier. This makes our programs shorter and more readable.

It also allows us to perform tasks that would normally be done in external

conﬁguration ﬁles inside the codebase instead. This makes it far easier to see

what’s happening. The following code deﬁnes the model class for a project.

Don’t worry about the details for now. Instead, just think about how much

information is being expressed in a few lines of code.

class Project < ActiveRecord::Base

belongs_to :portfolio

has_one :project_manager

has_many :milestones

has_many :deliverables, :through => :milestones

validates :name, :description, :presence => true

validates :non_disclosure_agreement, :acceptance => true

validates :short_name, :uniqueness => true

end

Two other philosophical underpinnings keep Rails code short and readable:

DRY and convention over conﬁguration. DRY stands for don’t r e p e a t yourself :

every piece of knowledge in a system should be expressed in just one place.

Rails uses the power of Ruby to bring that to life. Y o u ’ l l ﬁnd very little duplica-

tion in a Rails application; you say what you need to say in one place—a place

often suggested by the conventions of the MVC architecture—and then move

on. For programmers used to other web frameworks, where a simple change

to the schema could involve them in half a dozen or more code changes, this

was a revelation.

Convention over conﬁguration is crucial, too. It means that Rails has sensi-

ble defaults for just about every aspect of knitting together your application.

Follow the conventions, and you can write a Rails application using less code

than a typical Java web application uses in XML conﬁguration. If you need to

override the conventions, Rails makes that easy, too.

Developers coming to Rails found something else, too. Rails isn’t playing catch-

up with the new de facto web standards; it’s helping deﬁne them. And Rails

makes it easy for developers to integrate features such as Ajax and RESTful

interfaces into their code, because support is built in. (And if you’re not famil-

iar with Ajax and REST interfaces, never fear—we’ll explain them later in the

book.)

Report erratum

RAILSIS AGILE 18

Developers are worried about deployment too. They found that with Rails you

can deploy successive releases of your application to any number of servers

with a single command (and roll them back equally easily should the release

prove to be somewhat less than perfect).

Rails was extracted from a real-world, commercial application. It turns out

that the best way to create a framework is to ﬁnd the central themes in a

speciﬁc application and then bottle them up in a generic foundation of code.

When you’re developing your Rails application, you’re starting with half of a

really good application already in place.

But there’s something else to Rails—something that’s hard to describe. Some-

how, it just feels right. Of course, you’ll have to take our word for that until

you write some Rails applications for yourself (which should be in the next

forty-ﬁve minutes or so...). That’s what this book is all about.

Rails Is Agile

The title of this book is Agile W e b Development with Rails. Y o u may be sur-

prised to discover that we don’t have explicit sections on applying agile prac-

tices X, Y , and Z to Rails coding.

The reason is both simple and subtle. Agility is part of the fabric of Rails.

Let’s look at the values expressed in the Agile Manifesto as a set of four pref-

erences:

• Individuals and interactions over processes and tools

• W o r k i n g software over comprehensive documentation

• Customer collaboration over contract negotiation

• Responding to change over following a plan

Rails is all about individuals and interactions. There are no heavy toolsets,

no complex conﬁgurations, and no elaborate processes. There are just small

groups of developers, their favorite editors, and chunks of Ruby code. This

leads to transparency; what the developers do is reﬂected immediately in what

the customer sees. It’s an intrinsically interactive process.

Rails doesn’t denounce documentation. Rails makes it trivially easy to cre-

ate HTML documentation for your entire codebase. But the Rails development

process isn’t driven by documents. Y o u won’t ﬁnd 500-page speciﬁcations at

the heart of a Rails project. Instead, you’ll ﬁnd a group of users and devel-

opers jointly exploring their need and the possible ways of answering that

need. Y o u ’ l l ﬁnd solutions that change as both the developers and the users

become more experienced with the problems they’re trying to solve. Y o u ’ l l ﬁnd

1. http://agilemanifesto.org/. Dave Thomas was one of the seventeen authors of this document.

Report erratum

WHOTHISBOOKIS FOR 19

a framework that delivers working software early in the development cycle.

This software may be rough around the edges, but it lets the users start to get

a glimpse of what you’ll be delivering.

In this way, Rails encourages customer collaboration. When customers see

just how quickly a Rails project can respond to change, they start to trust

that the team can deliver what’s required, not just what has been requested.

Confrontations are replaced by “What if?” sessions.

That’s all tied to the idea of being able to respond to change. The strong, almost

obsessive, way that Rails honors the DRY principle means that changes to

Rails applications impact a lot less code than the same changes would in other

frameworks. And since Rails applications are written in Ruby, where concepts

can be expressed accurately and concisely, changes tend to be localized and

easy to write. The deep emphasis on both unit and functional testing, along

with support for test ﬁxtures and stubs during testing, gives developers the

safety net they need when making those changes. W i t h a good set of tests in

place, changes are less nerve-racking.

Rather than constantly trying to tie Rails processes to the agile principles,

we’ve decided to let the framework speak for itself. As you read through the

tutorial chapters, try to imagine yourself developing web applications this way:

working alongside your customers and jointly determining priorities and solu-

tions to problems. Then, as you read the more advanced concepts that follow

in Part III, see how the underlying structure of Rails can enable you to meet

your customers’ needs faster and with less ceremony.

One last point about agility and Rails: although it’s probably unprofessional

to mention this, think how much fun the coding will be.

Who This Book Is For

This book is for programmers looking to build and deploy web-based applica-

tions. This includes application programmers who are new to Rails (and per-

haps even new to Ruby) and ones who are familiar with the basics but want a

more in-depth understanding of Rails.

W e presume some familiarity with HTML, Cascading Style Sheets (CSS), and

JavaScript, in other words, the ability to view source on web pages. Y o u do not

need to be an expert on these subjects; the most you will ever be expected to do

is to copy and paste material from the book, all of which can be downloaded.

How T o Read This Book

The ﬁrst part of this book makes sure you are ready. By the time you are done

with it, you will have been introduced to Ruby (the language), you will have

Report erratum

HOWTO READTHISBOOK 20

been exposed to an overview of Rails itself, you will have both Ruby and Rails

installed, and you will have veriﬁed this installation with a simple example.

The next part takes you through the concepts behind Rails via an extended

example; we build a simple online store. It doesn’t take you one by one through

each component of Rails (“here is a chapter on models, here is a chapter on

views,” and so forth). These components are designed to work together, and

each chapter in this section tackles a speciﬁc set of related tasks that involve

a number of these components working together.

Most folks seem to enjoy building the application along with the book. If you

don’t want to do all that typing, you can cheat and download the source code

(a compressed tar ar chive or a zip ﬁle).

The third part of the book, starting on page 258, surveys the entire Rails

ecosystem. This starts with the functions and facilities of Rails that you will

now be familiar with. It then covers a number of key dependencies that the

Rails framework makes use of that contribute directly to the overall function-

ality that the Rails framework delivers. Finally, there is a survey of a number

of popular plugins that augment the Rails framework and make Rails an open

ecosystem rather than merely a framework.

Along the way, you’ll see various conventions we’ve adopted.

Live Code

Most of the code snippets we show come from full-length, running exam-

ples that you can download. To help you ﬁnd your way, if a code listing

can be found in the download, there’ll be a bar before the snippet (just

like the one here).

Download w o r k / d e m o 1 / a p p / c o n t r o l l e r s / s a y _ c o n t r o l l e r. r b

class SayController < ApplicationController

def hello

end

def goodbye

end

This contains the path to the code within the download. If you’re reading

the ebook version of this book and your ebook viewer supports hyper-

links, you can click the bar, and the code should appear in a br owser

window. Some browsers (such as Safari) will mistakenly try to interpret

some of the templates as HTML. If this happens, view the source of the

page to see the real source code.

2. http://pragprog.com/titles/rails4/source_code has the links for the downloads.

Report erratum

剩余456页未读，继续阅读

gaxuhongyu

粉丝: 6
资源: 19

Rails 3 开发指南：Agile Web Development with Rails 4th Edition

Rails 4 移动开发实战：Agile Web Development with Rails 2013解读

Rails 3 开发指南：Agile Web Development with Rails (第4版)

精通Rails：Agile Web Development with Rails第四版

Pragmatic.Bookshelf.Agile.Web.Development.with.Rails.5

(应用Rails进行敏捷Web开发(第4版) Agile.Web.Development.with.Rails.4th.Edition 原版

Agile.Web.Application.Development.with.Yii1.1.and.PHP5

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

Packtpub.Agile.Web.Application.Development.with.Yii1.1.and.PHP5.Aug.2010.rar

Agile.Web.Development.with.Rails.3nd.Edition.Beta.rar

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

最新资源