CLASSES 634

	Finally, we could simplify this method. The value returned by a Ruby method
	is the value of the last expression evaluated, so we can get rid of the temporary
	variable and the return statement altogether.
	def say_goodnight(name)
	"Good night, #{name.capitalize}"
	end
	puts say_goodnight('ma')
A.4	Classes
	Here’s a Ruby class definition.
Line 1	class Order < ActiveRecord::Base
-

-has_many :line_items

-

5 def self.find_all_unpaid

-find(:all, 'paid = 0')

-end

-

-def total

10

sum = 0

-line_items.each {|li| sum += li.total}

-end

-end

Class definitions start with the keyword class followed by the class name (which must start with an uppercase letter). This Order class is defined to be a subclass of the class Base within the ActiveRecord module.

Rails makes heavy use of class-level declarations. Here has_many is a method that’s defined by Active Record. It’s called as the Order class is being defined. Normally these kinds of methods make assertions about the class, so in this book we call them declarations.

Within a class body you can define class methods and instance methods. Prefixing a method name with self. (as we do on line 5) makes it a class method: it can be called on the class generally. In this case, we can make the following call anywhere in our application.

to_collect = Order.find_all_unpaid

Regular method definitions create instance methods (such as the definition of total on line 9). These are called on objects of the class. In the following example, the variable order references an Order object. We defined the total method in the preceding class definition.

puts "The total is #{order.total}"

Note the difference between the find_all_unpaid and total methods. The first is not specific to a particular order, so we define it at the class level and call it via

Report erratum

CLASSES 635

the class itself. The second applies to one order, so we define it as an instance method and invoke it on a specific order object.

Objects of a class hold their state in instance variables. These variables, whose names all start with @, are available to all the instance methods of a class. Each object gets its own set of instance variables.

class	Greeter
def	initialize(name)
@name = name
end
def	say(phrase)
puts "#{phrase},		#{@name}"
end
end
g1 = Greeter.new("Fred")
g2 = Greeter.new("Wilma" )
g1.say("Hello" )		#=>	Hello, Fred
g2.say("Hi")		#=>	Hi, Wilma

Instance variables are not directly accessible outside the class. To make them available, write methods that return their values.

class Greeter

def initialize(name) @name = name

end

def name @name

end

def name=(new_name) @name = new_name

end end

g = Greeter.new("Barney" )

puts	g.name	#=> Barney
g.name = "Betty"
puts	g.name	#=> Betty

Ruby provides convenience methods that write these accessor methods for you (which is great news for folks tired of writing all those getters and setters).

class Greeter
attr_accessor	:name	# create reader and writer methods
attr_reader	:greeting	#	create	reader	only
attr_writer	:age	#	create	writer	only

Report erratum

MODULES 636

Private and Protected

A class’s instance methods are public by default; anyone can call them. You’ll probably want to override this for methods that are intended to be used only by other class instance methods.

class MyClass

def m1 # this method is public end

protected

def m2 # this method is protected end

private

def m3 # this method is private end

end

The private directive is the strictest; private methods can be called only from within the same instance. Protected methods can be called both in the same instance and by other instances of the same class and its subclasses.

A.5 Modules

Modules are similar to classes in that they hold a collection of methods, constants, and other module and class definitions. Unlike classes, you cannot create objects based on modules.

Modules serve two purposes. First, they act as a namespace, letting you define methods whose names will not clash with those defined elsewhere. Second, they allow you to share functionality between classes—if a class mixes in a module, that module’s instance methods become available as if they had been defined in the class. Multiple classes can mix in the same module, sharing the module’s functionality without using inheritance. You can also mix multiple modules into a single class.

Rails uses modules extensively. For example, helper methods are written in modules. Rails automatically mixes these helper modules into the appropriate view templates. For example, if you wanted to write a helper method that would be callable from views invoked by the store controller, you could define the following module in the file store_helper.rb in the app/helpers directory.

module StoreHelper

def capitalize_words(string) string.gsub(/\b\w/) { $&.upcase }

end end

Report erratum

ARRAYS AND HASHES 637

A.6 Arrays and Hashes

Ruby’s arrays and hashes are indexed collections. Both store collections of objects, accessible using a key. With arrays, the key is an integer, whereas hashes support any object as a key. Both arrays and hashes grow as needed to hold new elements. It’s more efficient to access array elements, but hashes provide more flexibility. Any particular array or hash can hold objects of differing types; you can have an array containing an integer, a string, and a floating-point number, for example.

You can create and initialize a new array object using an array literal—a set of elements between square brackets. Given an array object, you can access individual elements by supplying an index between square brackets, as the next example shows. Ruby array indices start at zero.

a = [ 1, 'cat', 3.14 ]		# array with three elements
a[0]		# access the first element (1)
a[2]	= nil	#	set the third element
		#	array now [ 1, 'cat', nil ]

You may have noticed that we used the special value nil in this example. In many languages, the concept of nil (or null) means “no object.” In Ruby, that’s not the case; nil is an object, just like any other, that happens to represent nothing.

The method << is commonly used with arrays. It appends a value to its receiver.

ages = []

for person in @people ages << person.age

end

Ruby has a shortcut for creating an array of words.

a= [ 'ant', 'bee', 'cat', 'dog', 'elk' ]

# this is the same:

a= %w{ ant bee cat dog elk }

Ruby hashes are similar to arrays. A hash literal uses braces rather than square brackets. The literal must supply two objects for every entry: one for the key, the other for the value. For example, you may want to map musical instruments to their orchestral sections.

inst_section	= {
:cello	=> 'string',
:clarinet	=> 'woodwind',
:drum	=> 'percussion',
:oboe	=> 'woodwind',
:trumpet	=> 'brass',
:violin	=> 'string'
}

Report erratum

CONTROL STRUCTURES 638

The thing to the left of the => is the key, and that on the right is the corresponding value. Keys in a particular hash must be unique—you can’t have two entries for :drum. The keys and values in a hash can be arbitrary objects— you can have hashes where the values are arrays, other hashes, and so on. In Rails, hashes typically use symbols as keys. Many Rails hashes have been subtly modified so that you can use either a string or a symbol interchangably as a key when inserting and looking up values.

Hashes are indexed using the same square bracket notation as arrays.

inst_section[:oboe]	#=> 'woodwind'
inst_section[:cello]	#=>	'string'
inst_section[:bassoon]	#=>	nil

As the last example shows, a hash returns nil when indexed by a key it doesn’t contain. Normally this is convenient, because nil means false when used in conditional expressions.

Hashes and Parameter Lists

You can pass hashes as parameters on method calls. Ruby allows you to omit the braces, but only if the hash is the last parameter of the call. Rails makes extensive use of this feature. The following code fragment shows a two-element hash being passed to the redirect_to method. In effect, though, you can ignore the fact that it’s a hash and pretend that Ruby has keyword arguments.

redirect_to :action => 'show', :id => product.id

A.7 Control Structures

Ruby has all the usual control structures, such as if statements and while loops. Java, C, and Perl programmers may well get caught by the lack of braces around the bodies of these statements. Instead, Ruby uses the keyword end to signify the end of a body.

if count > 10

puts "Try again" elsif tries == 3

puts "You lose" else

puts "Enter a number" end

Similarly, while statements are terminated with end.

while weight < 100 and num_pallets <= 30 pallet = next_pallet()

weight += pallet.weight num_pallets += 1

end

Report erratum

REGULAR EXPRESSIONS 639

Ruby statement modifiers are a useful shortcut if the body of an if or while statement is just a single expression. Simply write the expression, followed by if or while and the condition.

puts "Danger, Will Robinson" if radiation > 3000

distance = distance * 1.2 while distance < 100

A.8 Regular Expressions

A regular expression lets you specify a pattern of characters to be matched in a string. In Ruby, you typically create a regular expression by writing /pattern/ or %r{pattern}.

For example, you could write a pattern that matches a string containing the text Perl or the text Python using the regular expression /Perl|Python/.

The forward slashes delimit the pattern, which consists of the two things we’re matching, separated by a vertical bar (|). This bar character means “either the thing on the left or the thing on the right,” in this case either Perl or Python. You can use parentheses within patterns, just as you can in arithmetic expressions, so you could also have written this pattern as /P(erl|ython)/. Programs typically test strings against regular expressions using the =~ match operator.

if line =~ /P(erl|ython)/

puts "There seems to be another scripting language here" end

You can specify repetition within patterns. /ab+c/ matches a string containing an a followed by one or more b’s, followed by a c. Change the plus to an asterisk, and /ab*c/ creates a regular expression that matches one a, zero or more b’s, and one c.

Ruby’s regular expressions are a deep and complex subject; this section barely skims the surface. See the PickAxe [TFH05] book for a full discussion.

A.9 Blocks and Iterators

Code blocks are just chunks of code between braces or between do...end. A common convention is that people use braces for single-line blocks and do/end for multiline blocks.

{ puts "Hello" }	# this is a block
do	###
club.enroll(person)	# and so is this
person.socialize	#
end	###

Report erratum

EXCEPTIONS 640

A block must appear after the call to a method; put the start of the block at the end of the source line containing the method call. For example, in the following code, the block containing puts "Hi" is associated with the call to the method greet.

greet { puts "Hi" }

If the method has parameters, they appear before the block.

verbose_greet("Dave" , "loyal customer") { puts "Hi" }

A method can invoke an associated block one or more times using the Ruby yield statement. You can think of yield as being something like a method call that calls out to the block associated with the method containing the yield. You can pass values to the block by giving parameters to yield. Within the block, you list the names of the arguments to receive these parameters between vertical bars (|).

Code blocks appear throughout Ruby applications. Often they are used in conjunction with iterators: methods that return successive elements from some kind of collection, such as an array.

animals = %w( ant bee cat dog elk )	#	create an array
animals.each {|animal| puts animal }	#	iterate over the contents

Each integer N implements a times method, which invokes an associated block N times.

3.times { print "Ho! " }

#=> Ho! Ho! Ho!

A.10 Exceptions

Exceptions are objects (of class Exception or its subclasses). The raise method causes an exception to be raised. This interrupts the normal flow through the code. Instead, Ruby searches back through the call stack for code that says it can handle this exception.

Exceptions are handled by wrapping code between begin and end keywords and using rescue clauses to intercept certain classes of exception.

begin

content = load_blog_data(file_name) rescue BlogDataNotFound

STDERR.puts "File #{file_name} not found" rescue BlogDataFormatError

STDERR.puts "Invalid blog data in #{file_name}" rescue Exception => exc

STDERR.puts "General error loading #{file_name}: #{exc.message}" end

Report erratum

MARSHALING OBJECTS 641

A.11 Marshaling Objects

Ruby can take an object and convert it into a stream of bytes that can be stored outside the application. This process is called marshaling. This saved object can later be read by another instance of the application (or by a totally separate application), and a copy of the originally saved object can be reconstituted.

There are two potential issues when you use marshaling. First, some objects cannot be dumped: if the objects to be dumped include bindings, procedure or method objects, instances of class IO, or singleton objects or if you try to dump anonymous classes or modules, a TypeError will be raised.

Second, when you load a marshaled object, Ruby needs to know the definition of the class of that object (and of all the objects it contains).

Rails uses marshaling to store session data. If you rely on Rails to dynamically load classes, it is possible that a particular class may not have been defined at the point it reconstitutes session data. For that reason, you’ll use the model declaration in your controller to list all models that are marshaled. This preemptively loads the necessary classes to make marshaling work.

A.12 Interactive Ruby

irb—Interactive Ruby—is the tool of choice for executing Ruby interactively. irb is a Ruby shell, complete with command-line history, line-editing capabilities, and job control. You run irb from the command line. Once it starts, just type in Ruby code. irb shows you the value of each expression as it evaluates it.

% irb

irb(main):001:0> def sum(n1, n2)

irb(main):002:1>

n1 + n2

irb(main):003:1> end => nil

irb(main):004:0> sum(3, 4) => 7

irb(main):005:0> sum("cat", "dog") => "catdog"

You can run irb on Rails applications, letting you experiment with methods (and sometimes undo damage to your database). However, setting up the full Rails environment is tricky. Rather than do it manually, use the script/console wrapper, as shown on page 244.

A.13 Ruby Idioms

Ruby is a language that lends itself to idiomatic usage. There are many good resources on the Web showing Ruby idioms and Ruby gotchas. Here are just a few.

Report erratum

RUBY IDIOMS 642

•http://books.rubyveil.com/books/ThingsNewcomersShouldKnow

•http://www.rubygarden.org/faq

•http://en.wikipedia.org/wiki/Ruby_programming_language

•http://www.zenspider.com/Languages/Ruby/QuickRef.html

This section shows some common Ruby idioms that we use in this book.

methods such as empty! and empty?

Ruby method names can end with an exclamation mark (a bang method) or a question mark (a predicate method). Bang methods normally do something destructive to the receiver. Predicate methods return true or false depending on some condition.

a || b

The expression a || b evaluates a. If it isn’t false or nil, then evaluation stops and the expression returns a. Otherwise, the statement returns b. This is a common way of returning a default value if the first value hasn’t been set.

a ||= b

The assignment statement supports a set of shortcuts: a op= b is the same as a = a op b. This works for most operators.

count +=		1	# same as count = count +					1
price	*=	discount	#	price	=	price	*	discount
count	||= 0		#	count	=	count	|| 0

So, count ||= 0 gives count the value 0 if count doesn’t already have a value.

obj = self.new

Sometimes a class method needs to create an instance of that class.

class Person < ActiveRecord::Base def self.for_dave

Person.new(:name => 'Dave') end

end

This works fine, returning a new Person object. But later on, someone might subclass our class.

class Employee < Person

# .. end

dave = Employee.for_dave # returns a Person

The for_dave method was hardwired to return a Person object, so that’s what is returned by Employee.for_dave. Using self.new instead returns a new object of the receiver’s class, Employee.

Report erratum

RDOC DOCUMENTATION 643

require File.dirname(__FILE__) + ’/../test_helper’

Ruby’s require method loads an external source file into our application. This is used to include library code and classes that our application relies on. In normal use, Ruby finds these files by searching in a list of directories, the LOAD_PATH.

Sometimes we need to be specific about what file to include. We can do that by giving require a full filesystem path. The problem is, we don’t know what that path will be—our users could install our code anywhere.

Wherever our application ends up getting installed, the relative path between the file doing the requiring and the target file will be the same. Knowing this, we can construct the absolute path to the target by taking the absolute path to the file doing the requiring (available in the special variable __FILE__), stripping out all but the directory name, and then appending the relative path to the target file.

A.14 RDoc Documentation

RDoc is a documentation system for Ruby source code. Just like JavaDoc, RDoc takes a bunch of source files and generates HTML documentation, using syntactic information from the source and text in comment blocks. Unlike JavaDoc, RDoc can produce fairly good content even if the source contains no comments. It’s fairly painless to write RDoc documentation as you write the source for your applications. RDoc is described in Chapter 16 of the PickAxe.

RDoc is used to document Ruby’s built-in and standard libraries. Depending on how your Ruby was installed, you might be able to use the ri command to access the documentation.

dave> ri String.capitalize

----------------------------------------------- String#capitalize str.capitalize => new_str

-----------------------------------------------------------------

Returns a	copy of	str with the			first character converted to
uppercase	and the	remainder to			lowercase.
"hello".capitalize			#=> "Hello"
"HELLO".capitalize			#=>	"Hello"
"123ABC".capitalize			#=>	"123abc"

If you used RubyGems to install Rails, you can access the Rails API documentation by running gem_server and then pointing your browser at the URL http://localhost:8808.

The rake doc:app task creates the HTML documentation for a Rails project, leaving it in the doc/app directory.

Report erratum

Appendix B

Configuration Parameters

As explained on page 240, Rails can be configured by setting options either in the global environment.rb file or in one of the environment-specific files in the config/environments directory.

Rails is configured via an object of class Rails::Configuration. This object is created in the environment.rb file and is passed around the various configuration files in the variable config. Older Rails applications used to set configuration options directly into Rails classes, but this is now deprecated. Rather than write

ActiveRecord::Base.table_name_prefix = "app_"

you should now write (within the context of an environment file)

config.active_record.table_name_prefix = "app_"

In the lists that follow, we show the options alphabetically within each Rails component.

B.1 Top-Level Configuration

config.breakpoint_server = true | false

Whether or not to use the breakpoint server.

config.cache_classes = true | false

Whether or not classes should be cached (left in memory) or reloaded at the start of each request. Set false in the development environment by default.

config.connection_adapters = [ ... ]

The list of database connection adapters to load. By default, all connection adapters are loaded. You can set this to be just the adapter(s) you will use to reduce your application’s load time. At the time of writing, the default value is

TOP-LEVEL CONFIGURATION 645

%w( mysql postgresql sqlite firebird sqlserver db2 oracle sybase openbase frontbase )

config.controller_paths = %w( app/controllers components )

The list of paths that should be searched for controllers.

config.database_configuration_file = "config/database.yml"

The path to the database configuration file to use.

config.frameworks = [ :active_record, :action_controller, :action_view, :action_mailer, :action_web_service ]

The list of Rails framework components that should be loaded. You can speed up application loading by removing those you don’t use.

config.load_paths = [dir...]

The paths to be searched by Ruby when loading libraries. Defaults to

•The mocks directory for the current environment

•app/controllers and subdirectories

•app, app/models, app/helpers, app/services, app/apis, components, config, lib, and vendor

•The Rails libraries

config.load_once_paths = [ ... ]

If there are autoloaded components in your application that won’t change between requests, you can add their paths to this parameter to stop Rails reloading them. By default, all autoloaded plugins are in this list, so plugins will not be reloaded on each request in development mode.

config.log_level = :debug | :info | :error | :fatal

The application-wide log level. Set to :debug in development and test, :info in production.

config.log_path = log/environment.log

The path to the log file. By default, this is a file in the log directory named after the current environment.

config.logger = Logger.new(...)

The log object to use. By default, Rails uses an instance of class Logger, initialized to use the given log_path and to log at the given log_level.

config.plugin_paths = "vendor/plugins"

The path to the root of the plugins directory.

config.view_path = "app/views"

Where to look for view templates.

config.whiny_nils = true | false

If set to true, Rails will try to intercept times when you invoke a method

Report erratum

ACTIVE RECORD CONFIGURATION 646

on an uninitialized object. For example, if your @orders variable is not set and you call @orders.each, Ruby will normally simply say something like “undefined method ‘each’ for nil.” With whiny_nils enabled, Rails will intercept this and instead say that you were probably expecting an array. On by default in development.

B.2 Active Record Configuration

config.active_record.allow_concurrency = true | false

If true, a separate database connection will be used for each thread. Because Rails is not thread-safe when used to serve web applications, this variable is false by default. You might consider (gingerly) setting it to true if you are writing a multithreaded application that uses Active Record outside of the scope of the rest of Rails.

config.active_record.colorize_logging = true | false

By default, Active Record log messages have embedded ANSI control sequences, which colorize certain lines when viewed using a terminal application that supports these sequences. Set the option to false to remove this colorization.

config.active_record.default_timezone = :local | :utc

Set to :utc to have dates and times loaded from and saved to the database treated as UTC.

config.active_record.generate_read_methods = true | false

The default value of true means that Active Record will generate a regular Ruby method for a model’s attribute the first time you access that attribute. If false, Active Record uses method_missing to intercept every call to read an attribute. The former is faster, but the latter is useful in obscure circumstances in development mode (for example if you delete a column in a table and need to ensure that the corresponding accessor goes away on subsequent requests).

config.active_record.lock_optimistically = true | false

If false, optimistic locking is disabled. (See Section 19.4, Optimistic Locking, on page 389.)

config.active_record.logger =logger

Accepts a logger object, which should be compatible with the Log4R interface. This is used internally to record database activity. It is also available to applications that want to log activity via the logger attribute.

config.active_record.pluralize_table_names = true | false

If false, class names will not be pluralized when creating the corresponding table names.

Report erratum

ACTIVE RECORD CONFIGURATION 647

config.active_record.primary_key_prefix_type =option

If option is nil, the default name for the primary key column for each table is id. If :table_name, the table name is prepended. Add an underscore between the table name and the id part by setting the option to the value

:table_name_with_underscore.

config.active_record.record_timestamps = true | false

Set to false to disable the automatic updating of the columns created_at, created_on, updated_at, and updated_on. This is described on page 375.

config.active_record.table_name_prefix ="prefix"

Prepend the given strings when generating table names. For example, if the model name is User and the prefix string is "myapp-", Rails will look for the table myapp-users. This might be useful if you have to share a database among different applications or if you have to do development and testing in the same database.

config.active_record.table_name_suffix ="suffix"

Append the given strings when generating table names.

config.active_record.record_timestamps = :sql | :ruby

Controls the format used when dumping a database schema. This is significant when running tests, because Rails uses the schema dumped from development to populate the test database. The :ruby format creates a file that looks like a big migration: it can be used portably to load a schema into any supported database (allowing you to use a different database type in development and testing). However, schemas dumped this way will contain only things that are supported by migrations. If you used any execute statements in your original migrations, it is likely that they will be lost when the schema is dumped.

If you specify :sql as the format, the database will be dumped using a format native to the particular database. All schema details will be preserved, but you won’t be able to use this dump to create a schema in a different type of database.

Miscellaneous Active Record Configuration

These parameters are set using the old-style, assign-to-an-attribute syntax.

ActiveRecord::Errors.default_error_messages =hash

A hash of standard validation failure messages. You can replace these with your own messages, perhaps for internationalization purposes. The default set are

ActiveRecord::Errors.default_error_messages = { :inclusion => "is not included in the list", :exclusion => "is reserved",

Report erratum

ACTION CONTROLLER CONFIGURATION 648

:invalid => "is invalid",

:confirmation => "doesn't match confirmation", :accepted => "must be accepted",

:empty => "can't be empty", :blank => "can't be blank",

:too_long => "is too long (maximum is %d characters)", :too_short => "is too short (minimum is %d characters)",

:wrong_length => "is the wrong length (should be %d characters)", :taken => "has already been taken",

:not_a_number => "is not a number"

}

ActiveRecord::Migration.verbose = true | false

If true, the default, migrations will report what they do to the console.

ActiveRecord::SchemaDumper.ignore_tables = [ ... ]

An array of strings or regular expressions. If schema_format is set to :ruby, tables whose names match the entries in this array will not be dumped. (But, then again, you should probably not be using a schema format of :ruby if this is the case.)

B.3 Action Controller Configuration

config.action_controller.asset_host =url

Sets the host and/or path of stylesheet and image assets linked using the asset helper tags. Defaults to the public_html directory of the application.

config.action_controller.asset_host = "http://media.my.url"

config.action_controller.consider_all_requests_local = true | false

The default setting of true means that all exceptions will display error and backtrace information in the browser. Set to false in production to stop users from seeing this information.

config.action_controller.default_charset = "utf-8"

The default character set for template rendering.

config.action_controller.debug_routes = true | false

Although defined, this parameter is no longer used.

config.action_controller.fragment_cache_store =caching_class

Determines the mechanism used to store cached fragments. Fragment cache storage is discussed on page 518.

config.action_controller.ignore_missing_templates = false | true

If true, no error will be raised if a template cannot be found. This might be useful during testing.

Report erratum

ACTION VIEW CONFIGURATION 649

config.action_controller.logger =logger

Sets the logger used by this controller. The logger object is also available to your application code.

config.action_controller.page_cache_directory =dir

Where cache files are stored. Must be the document root for your web server. Defaults to your application’s public directory.

config.action_controller.page_cache_extension =string

Overrides the default .html extension used for cached files.

config.action_controller.param_parsers[:type] =proc

Registers a parser to decode an incoming content type, automatically populating the params hash from incoming data. Rails by default will parse incoming application/xml data and comes with a parser for YAML data. See the API documentation for more details.

config.action_controller.perform_caching = true | false

Set to false to disable all caching. (Caching is by default disabled in development and testing and enabled in production.)

config.action_controller.session_store =name or class

Determines the mechanism used to store sessions. This is discussed starting on page 440.

config.action_controller.template_class =class

Defaults to ActionView::Base. You probably don’t want to change this.

config.action_controller.template_root =dir

Template files are looked for beneath this directory. Defaults to app/views.

config.action_controller.view_controller_internals = true | false

Templates can normally access the controller attributes request, response, session, and template. Setting this option to false removes this access.

B.4 Action View Configuration

config.action_view.cache_template_extensions = false | true

If true, the first time Rails finds a template that matches a given name, it will always use that template when looking up that name. If false (the default in development), it will look for newly added templates with different file extensions that map the name.

config.action_view.cache_template_loading = false | true

Turn on to cache the rendering of templates, which improves performance. However, you’ll need to restart the server should you change a template on disk. Defaults to false, so templates are not cached.

Report erratum

ACTION MAILER CONFIGURATION 650

config.action_view.debug_rjs = true | false

If true, javaScript generated by RJS will be wrapped in an exception handler that will display a browser-side alert box on error.

config.action_view.erb_trim_mode = "-"

Determines how ERb handles lines in rhtml templates. See the discussion on page 469.

config.action_view.field_error_proc =proc

This Ruby proc is called to wrap a form field that fails validation. The default value is

Proc.new do |html_tag, instance|

%{<div class="fieldWithErrors" >#{html_tag}</div>} end

B.5 Action Mailer Configuration

The use of these settings is described in Section 24.1, E-mail Configuration, on page 567.

config.action_mailer.default_charset = "utf-8"

The default character set for e-mails.

config.action_mailer.default_content_type = "text/plain"

The default content type for e-mails.

config.action_mailer.default_implicit_parts_order = %w( text/html text/enriched text/plain)

We saw on page 574 how Rails will automatically generate multipart messages if it finds template files named xxx.text.plain.rhtml, xxx.text.html.rhtml, and so on. This parameter determines the order in which these parts are added to the e-mail and hence the priority given to them by an e-mail client.

config.action_mailer.default_mime_version = "1.0"

The default mime version for e-mails.

config.action_mailer.delivery_method = :smtp | :sendmail | :test

Determine the delivery method for e-mail. Use with session_settings. See the description starting on page 568.

config.action_mailer.logger =logger

Set this to override the default logger used by the mailer. (If not set, the overall application logger is used.)

config.action_mailer.perform_deliveries = true | false

If false, the mailer will not deliver e-mail.

Report erratum

TEST CASE CONFIGURATION 651

config.action_mailer.raise_delivery_errors = true | false

If true, an exception will be raised if e-mail delivery fails. Note that Rails knows only about the initial handoff of e-mail to a mail transfer agent: it cannot tell whether mail actually reached its recipient. This parameter is true in the test environment, but by default is false in the others.

config.action_mailer.server_settings =hash

See the description starting on page 568.

config.action_mailer.template_root = "app/views"

Action Mailer looks for templates beneath this directory.

B.6 Test Case Configuration

The following options can be set globally but are more commonly set inside the body of a particular test case.

# Global setting Test::Unit::TestCase.use_transactional_fixtures = true

# Local setting

class WibbleTest < Test::Unit::TestCase self.use_transactional_fixtures = true

# ...

pre_loaded_fixtures = false | true

If true, the test cases assume that fixture data has been loaded into the database prior to the tests running. Use with transactional fixtures to speed up the running of tests.

use_instantiated_fixtures = true | false | :no_instances

Setting this option to false (the default) disables the automatic loading of fixture data into an instance variable. Setting it to :no_instances creates the instance variable but does not populate it.

use_transactional_fixtures = true | false

If true (the default), changes to the database will be rolled back at the end of each test.

Report erratum