Product Overview

Simply Rails 2

Index

A

access log, (Using the Rails Logging Tool)

accessor methods

about, (Accessor Methods)
defined, (Object-level Functionality)
types of, (Accessor Methods)

action (see method)

ActionController module, (ActionController (the Controller))

defined, (MVC the Rails Way)
function, (ActionController (the Controller))

ActionController::Base class, (ActionController (the Controller)), (Understanding the Output)

ActionMailer, (ActionMailer)

ActionPack library, (MVC the Rails Way)

ActionPack module

log files, (Revisiting the Logs)
MVC architecture, (The ActionPack Module)

ActionView helpers

about, (Introducing ActionView Helpers)
writing, (Writing an ActionView Helper)

ActionView module, (MVC the Rails Way), (ActionView (the View)), (Creating Static Pages)

ActionView templates, (Creating the View)

ActionView::Base, (ActionView (the View))

ActiveRecord dynamic finder method, (Making a Model Taggable)

ActiveRecord module, (ActiveRecord (the Model))

applications, (ActiveRecord (the Model))
counter cache, (Introducing the Counter Cache)
database abstraction, (Database Abstraction)
database tables, (Database Tables), (Determining Where a Story Lives)
defined, (MVC the Rails Way)
defining relationships between objects, (Defining Relationships Between Objects)
logging functionality, (Revisiting the Logs)
saving an object, (Saving an Object)
validations, (Applying Validations)

ActiveRecord object

creating, (Creating a User)
storing in session container, (Adding Functionality to the Controller)
syntax for creating, (Saving an Object)

ActiveRecord prefixes, (Introducing Model Callbacks)

ActiveRecord Store session container, (The ActiveRecord Store Session Container)

ActiveRecord::Base class, (Saving an Object)

acts, (What acts_as_taggable_on_steroids Does)

acts_as_list, (What acts_as_taggable_on_steroids Does)

acts_as_nested_set, (What acts_as_taggable_on_steroids Does)

acts_as_taggable_on_steroids plugin, (Introducing the acts_as_taggable_on_steroids Plugin)

columns in taggable table, (Creating a Migration for the Plugin)
creating a migration for, (Creating a Migration for the Plugin)
installing, (Installing the acts_as_taggable_on_steroids Plugin)
making a model taggable, (Making a Model Taggable)
polymorphic associations, (Understanding Polymorphic Associations)
tables, (Creating a Migration for the Plugin)
what it does, (What acts_as_taggable_on_steroids Does)

acts_as_tree, (What acts_as_taggable_on_steroids Does)

add_column function, (Making Room for the Cache)

after filters, (After Filters)

after_ callbacks, (Introducing Model Callbacks)

after_create, (Introducing Model Callbacks)

after_filter method, (After Filters)

Agile development methods, (Agile Development)

Agile development practices, (Agile Development)

Ajax

about, (Don’t Repeat Yourself)
and Rails, (Remote Scripting with Prototype)
applications, (Introducing Ajax)
function, (Introducing Ajax)
what is it?, (Ajax and Rails)
XmlHttpRequest object, (Introducing Ajax)

Ajax-powered to-do list without visual feedback, (Adding Visual Effects with script.aculo.us)

Ajax voting

testing, (Testing Ajax Voting)

:all argument, (Retrieving Records)

Apache web server

about, (Apache)
installing on Windows, (Installing on Windows)
mod_ruby extension, (The mod_ruby Extension)
moving to the production system, (Moving to the Production System)
proxy module, (Setting up Apache)
setting up for Mongrel, (Setting up Apache)

apachect1 reload, (Setting up Apache)

app object, (Revisiting the Rails Console)

app subdirectory, (MVC the Rails Way)

application.js (file), (Including the JavaScript Libraries)

ApplicationController class, (Understanding the Output), (Protecting the Form), (Requiring Users to Log In), (Using the Rails Logging Tool)

application’s performance

monitoring by checking log files, (Taking Benchmarks from Log Files)

architecture of Rails application, (Choosing a Production Environment)

argument, (Ruby Is an Object Oriented Language)

around filters, (Around Filters)

Array (class), (Arrays)

creating from a list of Strings, (Arrays)
creating new, shortcut, (Arrays)
first element in, (Arrays)
retrieving elements from, (Arrays)
retrieving records, (Retrieving Records)
use in data management, (Arrays)
use with blocks, (Blocks)
use with for loops, (for Loops)

assert_equal assertion, (Testing a Story’s Relationship to a Vote), (Testing a User’s Relationship to a Story), (Testing a Story’s Relationship to a User), (Testing a User’s Relationship to a Vote), (Testing the Creation of the Initial Vote)

assert_nil assertion, (Testing a Failed Login), (Testing a Logout)

assert_not_nil assertion, (Writing a Functional Test), (Testing a Logout)

assert_redirected_to assertion, (Testing Regular HTTP Voting)

assert_redirected_to method, (Testing a Successful Login), (Testing Redirection After Logout)

assert_response assertion, (Writing a Functional Test), (Testing a Failed Login), (Testing Redirection After Logout)

assert_routing assertion, (Testing the Routing Configuration)

assert_select assertion, (Writing More Functional Tests), (Testing Page Rendering), (Testing Page Headings), (Testing the Story Display Page), (Testing the Display of Stories by Tag)

assert_template assertion, (Writing a Functional Test), (Testing a Failed Login)

assertions, (Using Assertions)

assigning our first tags, (Assigning Our First Tags)

assignment operator (=), (while and until Loops)

associating stories with users, (Associating Stories with Users)

displaying the submitter, (Displaying the Submitter)
storing the submitter, (Storing the Submitter)

associations

class names, (Introducing the has_many :through Association)
defined, (Introducing Relationships)
has_many :through, (Introducing the has_many :through Association)
join model relationship, (Introducing the Join Model Relationship)

associations between objects, (Defining Relationships Between Objects)

@ sign, (Instance Variables)

attributes

adding to stories, (Adding a Model Attribute)
changing the value of, (Updating Records)

auto-completion of strings, (Adding Visual Effects with script.aculo.us)

auto-voting, (Auto-voting for Newly Submitted Stories)

automated testing, (Automated Testing)

B

back-end component options, (Choosing a Production Environment), (Back-end Options)

backslash character (\), (Strings)

Basecamp, (History)

before-and-after check, (Testing Vote Storage)

before filters, (Before Filters), (Allowing Users to Log Out), (Storing the Submitter), (Using the Rails Logging Tool)

before_create, (Introducing Model Callbacks)

before_delete, (Introducing Model Callbacks)

before_filter method, (Before Filters), (Requiring a Login to Vote)

before_save, (Introducing Model Callbacks)

belongs_to clause, (Introducing the belongs_to Clause)

benchmark class method, (Manual Benchmarking)

benchmarking, (Benchmarking Your Application)

definition, (Benchmarking Your Application)
information from log files, (Taking Benchmarks from Log Files)
manual, (Manual Benchmarking)

Bignum (class), (Numerics)

bin action, (Implementing the Voting Bin), (Testing Page Headings)

bloat, (Convention Over Configuration)

blocks, (Blocks)

defined, (Control Structures)
parameters for, (Blocks)

boolean values, (Method Notation)

Breakpoint library

ruby-debug tool, (Meeting ruby-debug)

breakpoint statements (see ruby-debug tool)

building a foundation, (Building a Foundation)

creating the standard directory structure, (Creating the Standard Directory Structure)
standard directory structure, (One Directory Structure to Rule Them All)

building the example web application, (Building the Example Web Application)

C

caching, (Caching)

available for pages, actions and page fragments, (The Implications of “Production”)

callback methods, (Introducing Model Callbacks)

callbacks

adding, (Adding a Callback)
alternative syntax, (Introducing Model Callbacks)
defined, (Auto-voting for Newly Submitted Stories)
in models, (Introducing Model Callbacks)

CamelCase, (ActionController (the Controller))

Capistrano (deployment and management system), (Capistrano)

cd command (change directory), (Staying Organized)

chaining statements together, (Chaining Statements Together)

class definition, (Understanding the Output), (Creating a Skeleton Migration File), (Understanding the Output)

class method, (The Interactive Ruby Shell (irb)), (Class-level Functionality)

class names, (ActionController (the Controller))

class variables, (Class-level Functionality)

class-level functionality, (Class-level Functionality)

classes, (Classes and Objects)

(see also Ruby classes)
and objects, (Ruby Is an Object Oriented Language)
naming, (ActionController (the Controller))

clean URLs, (Features of the Example Application)

code generation, (Code Generation)

:collection, (Styling the Voting History)

colon (:)

use before Symbols, (Symbols)

columns

adding to stories table, (Adding a Model Attribute)

comments in line of code, (Dot Notation)

compiled languages

about, (Compiled Languages)
performance against scripting languages, (The Great Performance Debate)

conditionals, (Conditionals)

defined, (Control Structures)
if construct, (The if Construct)
unless construct, (The unless Construct)

configuration files, (Convention Over Configuration), (Database Configuration)

console script, (Revisiting the Rails Console)

constants, (Variables and Constants)

ConTEXT (text editor), (Windows Text Editors)

control structures, (Control Structures)

blocks, (Control Structures), (Blocks)
conditionals, (Control Structures), (Conditionals)
loops, (Control Structures), (Loops)

controller class names, (Understanding the Output)

controller generator, (Generating a Controller)

running the generate Script, (Running the generate Script)
starting our application again, (Starting Our Application … Again)
understanding the output, (Understanding the Output)

controllers, (ActionController (the Controller))

(see also ActionController module)

adding functionality to, (Adding Functionality to the Controller)

communication with views via instance variables, (ActionView (the View))

for login functionality, (Creating the Controller)

models and views, (Convention Over Configuration)

modifying, (Modifying the Controller), (Modifying the Controller), (Adding Another Controller), (Modifying the Controller), (Creating the Controller)

MVC, (MVC in Theory)

testing, (Testing the Controller)

tagging functionality, (Testing the Controller)
user authentication, (Testing the Controllers)
voting functionality, (Testing the Controller)

controls.js (file), (Including the JavaScript Libraries)

convention over configuration, (Convention Over Configuration)

cookies

expiration date, (What’s a Cookie?)
session, (What’s a Session?)
setting expiration date, (What’s a Cookie?)
in testing, (Using Breakpoints in a Test)
what are they?, (What’s a Cookie?)

cost of software, (What Does All This Cost?)

count (class method), (Class-level Functionality)

counter cache

applying the migration, (Applying the Migration)
function, (Introducing the Counter Cache)
making room for the cache, (Making Room for the Cache)
testing additions to, (Testing Additions to the Counter Cache)
testing deletions from, (Testing Deletions from the Counter Cache)
udating the RJS template, (Updating the RJS Template)

counting votes

using counter cache, (Introducing the Counter Cache)

create (files), (Understanding the Output)

create class method, (Creating Records)

create method, (Testing the Voting History Order)

create stories file (example), (Understanding the Output), (Creating a Skeleton Migration File), (Creating Records)

migration using rake, (Using rake to Migrate Our Data)

:created_at, (Examining the Vote Migration)

creating a layout, (Creating a Layout)

creating dynamic pages, (Creating Dynamic Pages)

creating partials, (Creating the Partial)

creating records, (Creating Records)

creating static pages, (Creating Static Pages)

creating the database structure (production environment), (Moving to the Production System)

creating views, (Creating a View)

CRUD Verbs versus HTTP verbs, (REST and the Web)

current test-to-code ratio, (Running the Full Test Suite)

current user, (Retrieving the Current User), (Displaying the Name of the Current User), (Allowing Users to Log Out), (Storing the Submitter), (Testing a Logout)

displaying name of, (Displaying the Name of the Current User)
retrieving, (Retrieving the Current User)

custom class methods, (Class-level Functionality)

D

data integrity in development, (Displaying the Submitter)

data management

using Arrays, (Arrays)

database abstraction (ActiveRecord), (Database Abstraction)

database architecture of a Rails application, (The Database Configuration File)

database associations, (Defining Relationships Between Objects)

database configuration files, (Database Configuration)

database migrations (see migrations)

database relationships, (Introducing Relationships)

database schema, (Database Tables)

database schema definition, (Don’t Repeat Yourself)

database structure

creating (production environment), (Moving to the Production System)

database tables, (Database Tables)

creating for user model, (Generating a User Model)
naming, (Database Tables)
typical structure, (Database Tables)

date-formatting helper, (Styling the Voting History)

db namespace, (Using rake to Migrate Our Data)

debugging, (Debugging Your Application), (Debugging using ruby-debug)

(see also ruby-debug tool)
about, (Debugging)
overcoming problems in, (Overcoming Problems in Debugging)
using Rails logging tool, (Using the Rails Logging Tool)
within templates, (Debugging within Templates)

Debugging, (Debugging using ruby-debug)

declaring

resources, (Resources in Rails)

def keyword, (Instance Methods)

:default argument, (Making Room for the Cache)

default directory structure

conventions, (One Directory Structure to Rule Them All)
creating, (Creating the Standard Directory Structure)

default page, (Setting the Default Page)

default Rails welcome page, (Setting the Default Page)

degradation

fallback action for browsers, (Ensuring Graceful Degradation)

delete

use with Arrays, (Arrays)

deleting records, (Deleting Records)

deploying Shovell, (Deploying Shovell)

moving to the production system, (Moving to the Production System)
setting up Apache, (Setting up Apache)

deployment management systems, (Version Control and Deployment Management)

description column, (Adding a Description to Stories)

destroy method, (Deleting Records)

development environment

SQL statements, (Where’s the SQL?)

development environment (Rails), (Three Environments)

digg

Shovell project, (Creating the Standard Directory Structure)
what is it?, (What Is Digg?)

digg effect, (What Is Digg?)

digg homepage, (What Is Digg?)

do keyword, (Blocks)

don’t repeat yourself (see DRY programming)

dot notation, (Dot Notation)

down method, (Creating a Skeleton Migration File)

drag-and-drop, (Adding Visual Effects with script.aculo.us)

dragdrop.js (file), (Including the JavaScript Libraries)

DRY programming, (Don’t Repeat Yourself)

dynamic finder methods, (Retrieving Records)

dynamic pages

creating, (Creating Dynamic Pages)
defined, (Creating Static Pages)

E

each method, (Blocks), (Making Room for the Cache)

edit-in-place, (Adding Visual Effects with script.aculo.us)

effects.js (file), (Including the JavaScript Libraries)

else block, (The if Construct), (The unless Construct)

<em> tag, (Displaying the Name of the Current User)

Emacs (text editor), (Linux and Cross-platform Editors)

email

for error notification, (The Implications of “Production”), (Errors by Email)
handled via ActionMailer, (ActionMailer)
resulting from Exception Notification plugin, (The Implications of “Production”)

embedded Ruby (see ERb)

empty?

use in Arrays, (Arrays)
use with Hash, (Hashes)

encapsulation, (Classes and Objects)

end keyword, (Instance Methods), (The if Construct), (Blocks)

equation operator (==), (while and until Loops)

ERb syntax, (ActionView (the View))

ERb tags, (ActionView (the View)), (Creating Dynamic Pages), (Introducing the form_for Helper), (Avoiding Presentation Logic Spaghetti)

ERb templates, (Creating Static Pages)

error messages

by email, (The Implications of “Production”), (Errors by Email)
code excerpts in, (Debugging within Templates)
seen in production environment, (The Implications of “Production”)

errors attribute, (Writing a Unit Test), (Writing More Functional Tests)

example web application

building, (Building the Example Web Application)
features, (Features of the Example Application)
using digg, (What Is Digg?)

Exception Notification plugin, (The Implications of “Production”), (Errors by Email)

exists (folders), (Understanding the Output)

F

failed login, (Testing a Failed Login)

fallback action

for browsers, (Ensuring Graceful Degradation)

FastCGI protocol, (The FastCGI Protocol)

fetch_logged_in_user method, (Retrieving the Current User), (Allowing Users to Log Out), (Storing the Submitter), (Testing Display of the Username), (Using the Rails Logging Tool)

fetch_stories method, (Implementing the Voting Bin), (Manual Benchmarking)

files

naming, (ActionController (the Controller))

filter conditions, (Introducing Filter Conditions)

filter methods, (A Word on Filter Methods)

filters, (Introducing Filters)

after filters, (After Filters)
around filters, (Around Filters)
before filters, (Before Filters)

find (class method), (Retrieving Records)

find calls, (Adding Another Controller)

find operation, (Modifying the Controller)

find_by_, (Retrieving Records)

find_by_id method, (Retrieving the Current User)

find_by_link, (Retrieving Records)

find_by_name, (Retrieving Records)

find_tagged_with class method, (Making a Model Taggable), (Testing the Finding of a Story by Tag)

Firefox cookie manager, (What’s a Cookie?)

firewall, (Installing on Windows)

first

use with Arrays, (Arrays)

:first argument, (Retrieving Records), (Pulling in a Model)

first method, (Retrieving Records)

first tags

assigning, (Assigning Our First Tags)

Fixnum (class), (The Interactive Ruby Shell (irb)), (Numerics)

fixtures

defined, (Understanding the Output)
in functional tests, (Writing a Functional Test)
preparing, (Preparing the Fixtures), (Preparing the Fixtures)
user model, (Preparing the Fixtures)

flash

adding to, (Adding to the Flash)
retrieving data from, (Retrieving Data from the Flash)

flash areas

functional tests, (Writing More Functional Tests)
naming conventions, (Adding to the Flash)
passing messages, (Adding to the Flash)

flash content, (Adding to the Flash), (Retrieving Data from the Flash)

nil or blank, (Retrieving Data from the Flash)

Float (class), (Numerics)

follow_redirect! statement, (Creating Our First Integration Test), (Revisiting the Rails Console)

for loop, (for Loops)

form creation, (Creating a Form)

analyzing the HTML, (Analyzing the HTML)
modifying the controller, (Modifying the Controller)
using form_for helper, (Introducing the form_for Helper)

form element, (Writing More Functional Tests)

form tags, (Introducing the form_for Helper)

form_for helper, (Introducing the form_for Helper), (Creating the Template), (Improving the User Experience), (Creating the View)

syntax, (Introducing the form_for Helper)

form_tag helper, (Creating the View)

FormBuilder object, (Introducing the form_for Helper)

framework

applications, (Introducing Ruby on Rails)
definition, (Introducing Ruby on Rails)

free software licenses, (What Does All This Cost?)

front-end server platform, (Choosing a Production Environment)

front page, (Implementing the Front Page)

modifying the controller, (Modifying the Controller)
modifying the partial, (Creating the Partial)
modifying the view, (Modifying the View)
setting the default page, (Setting the Default Page)
styling, (Styling the Front Page)

full-stack

definition, (Introducing Ruby on Rails)

functional tests

comparison to integration tests, (Creating Our First Integration Test)
defined, (Testing the Form)
for the new action, (Writing More Functional Tests)
revealing test failures, (Debugging within Templates)
running, (Running a Functional Test)

G

gcc compiler

confirming installation, (Prerequisites)

gem command, (Installing RubyGems on a Mac), (Installing RubyGems on Linux)

generate command, (Code Generation), (Automated Testing)

generate Script

code generation, (Code Generation)
creating the model, (Creating the Model)
generating a user model, (Generating a User Model)
running, (Running the generate Script), (Running the generate Script)
sample output, (Code Generation)

generating a controller, (Generating a Controller)

generating a model, (Generating a Model)

managing data using the Rails Console, (Managing Data Using the Rails Console)
model generator, (The Model Generator)
modifying the schema using migrations, (Modifying the Schema Using Migrations)
SQL statements, (Where’s the SQL?)

generating a user model, (Generating a User Model)

generating a vote model, (Generating a Vote Model)

generating views with scaffolding, (Generating Views with Scaffolding)

GET, (Writing a Functional Test), (Ensuring Graceful Degradation), (Testing Page Rendering), (Testing Regular HTTP Voting), (Testing the Display of the Login Form), (Revisiting the Rails Console)

get_with_user, (Testing Display of the Username), (Testing Story Submission)

getters, (Accessor Methods)

global elements

testing, (Testing the Display of Global Elements)

global helpers, (Writing an ActionView Helper)

global variables, (Variables and Constants)

graceful degradation, (Adding Visual Effects with script.aculo.us)

gsub

use with Strings, (Strings)

gunzip command, (Installing Ruby on Linux)

H

has_and_belongs_to_many relationship, (Understanding Polymorphic Associations)

has_many :through association, (Introducing the has_many :through Association), (Testing the Join Model Relationship)

has_many clause, (Introducing the has_many Clause)

Hash (class), (Hashes)

methods, (Hashes)
saving data to the database, (Saving Data to the Database)
use with blocks, (Blocks)

#{ } syntax, (Introducing RJS Templates)

hash mark (#), (Dot Notation)

#( ), (Strings)

hashed password storage, (Creating a User)

headless mode, (Revisiting the Rails Console)

Heinemeier Hansson, David, (History), (Convention Over Configuration)

helper class, (Understanding the Output)

helper files, (Calling upon Our Trusty Helpers)

helper_method statement, (Abstracting Code Using helper_method)

helpers

about, (Calling upon Our Trusty Helpers)
form_for, (Introducing the form_for Helper)

hexadecimal address, (Standard Output)

highlighting effect, (Introducing RJS Templates)

HTML

in forms, (Analyzing the HTML)

.html.erb file extension, (ActionView (the View))

.html.erb templates, (Introducing RJS Templates), (Introducing Partials)

HTTP

and REST, (REST and the Web)
as stateless protocol, (Identifying Individual Users)

HTTP codes

shortcuts, (Writing a Functional Test)

HTTP GET, (Writing a Functional Test), (Ensuring Graceful Degradation), (Testing Page Rendering), (Testing Regular HTTP Voting), (Testing the Display of the Login Form), (Revisiting the Rails Console)

HTTP POST, (Writing More Functional Tests), (Testing Vote Storage), (Revisiting the Rails Console)

HTTP voting

testing, (Testing Regular HTTP Voting)

I

id

for retrieval, (Retrieving Records)

identifying individual users, (Identifying Individual Users)

if clause, (Requiring a Login to Vote)

if construct, (The if Construct)

if statement modifier, (The if Construct)

include file, (Analyzing the Skeleton File)

include?

use with Strings, (Strings)

incrementing a variable (+=), (Class-level Functionality)

indentation of code, (Instance Methods)

index action, (Understanding the Output), (Starting Our Application … Again), (Writing a Functional Test), (Implementing the Voting Bin), (Testing the Routing Configuration), (Testing Page Headings)

index.html.erb (file), (Understanding the Output)

individual users

identifying, (Identifying Individual Users)

inheritance, (Inheritance), (Saving an Object)

initialize (method), (Class-level Functionality)

instance methods, (Instance Methods), (Styling the Voting History), (Tweaking the Voting History), (A Word on Filter Methods), (Testing Additions to the Counter Cache), (Making a Model Taggable), (Updating the story Partial)

instance variables, (Object-level Functionality), (Instance Variables), (ActionView (the View)), (Passing Data Back and Forth)

instant messaging systems, (Identifying Individual Users)

InstantRails

control panel, (Installing on Windows), (The Interactive Ruby Shell (irb))
installing, (Installing on Windows)
starting, (Creating the Standard Directory Structure)

Integer (class), (Numerics), (Blocks)

Integer object

times method, (Blocks)
upto method, (Blocks)

integer values, (The Interactive Ruby Shell (irb))

integer?

use with Numeric subclasses, (Numerics)

integration tests, (Integration Tests)

creating the first test, (Creating Our First Integration Test)
defined, (Integration Testing), (Testing the Form)
functions, (Integration Tests)
how they work, (Creating Our First Integration Test)
in headless mode, (Revisiting the Rails Console)
running, (Running an Integration Test)
when to use?, (When to Use an Integration Test)

interactive Ruby shell, (The Interactive Ruby Shell (irb)), (Running Ruby Files)

interface, (Classes and Objects)

interpreter, (Scripting Languages), (Running Ruby Files)

(see also Ruby interpreter)

irb (see interactive Ruby shell)

irb output, (The Interactive Ruby Shell (irb))

J

JavaScript include files, (Including the JavaScript Libraries)

JavaScript libraries

including in applications layout, (Including the JavaScript Libraries)

Prototype, (Remote Scripting with Prototype), (Adding Visual Effects with script.aculo.us)

script.aculo.us, (Adding Visual Effects with script.aculo.us)

functionality, (Adding Visual Effects with script.aculo.us)

jEdit (text editor), (Linux and Cross-platform Editors)

join model relationship, (Introducing the Join Model Relationship)

has_many :through association, (Introducing the has_many :through Association)
testing, (Testing the Join Model Relationship)

.js.rjs file extension, (ActionView (the View))

K

keys

use with Hash, (Hashes)

L

last

use with Arrays, (Arrays)

last method, (Retrieving Records)

latest_votes method, (Tweaking the Voting History), (Testing the Voting History Order)

layout creation, (Creating a Layout)

adding style, (Adding Some Style)
establishing structure, (Establishing Structure)

layouts (templates), (ActionView (the View)), (Creating a Layout)

length

use with strings, (Strings)

lighttpd web server, (lighttpd)

link attribute, (Writing a Unit Test)

link column, (Retrieving Records)

link_to function, (Pulling in a Model)

Linux

text editors, (Linux and Cross-platform Editors)

Linux installation, (Installing on Linux)

installing Rails, (Installing Rails on Linux)
installing Ruby, (Installing Ruby on Linux)
installing RubyGems, (Installing RubyGems on Linux)
prerequisites, (Prerequisites)
using a package manager, (Using a Package Manager)

literal objects, (Literal Objects)

log files

about, (Revisiting the Logs)
taking benchmarks from, (Taking Benchmarks from Log Files)

log out (see logout)

logged_in? helper method, (Requiring Users to Log In), (Introducing ActionView Helpers)

logger, (Using the Rails Logging Tool)

logger object, (Using the Rails Logging Tool)

logging tool (Rails), (Using the Rails Logging Tool)

login

testing failed, (Testing a Failed Login)
testing redirection after, (Testing Redirection After Login)
testing successful, (Testing a Successful Login)

login form, (Creating the View), (Adding Functionality to the Controller)

testing display of, (Testing the Display of the Login Form)

login functionality, (Developing Login Functionality)

adding functionality to the controller, (Adding Functionality to the Controller)
creating the controller, (Creating the Controller)
creating the view, (Creating the View)

Login link, (Allowing Users to Log Out)

login method, (Redirecting the User), (Testing a Successful Login)

login parameter, (Creating the View)

login template, (Creating the View)

login values

adding functionality to the controller, (Adding Functionality to the Controller)
logging, (Using the Rails Logging Tool)
testing a successful login, (Testing a Successful Login)

login_logout div, (Testing Display of the Username)

login_reguired filter, (Protecting the Form), (Requiring Users to Log In)

logout

manual function for, (Allowing Users to Log Out)
testing, (Testing a Logout)

logout function, (Allowing Users to Log Out)

Logout link, (Allowing Users to Log Out)

logout parameter, (Creating the Controller)

loops, (Loops)

control structures, (Control Structures)
for loop, (for Loops)
while and until loops, (while and until Loops)

M

Mac OS X 10.4 (Tiger) and earlier installation, (Mac OS X 10.4 (Tiger) and Earlier)

command line, (Introducing the Command Line)
installing Rails, (Installing Rails on a Mac)
installing Ruby, (Installing Ruby on a Mac)
installing RubyGems, (Installing RubyGems on a Mac)
installing SQLite, (Installing SQLite on a Mac)
installing Xcode, (Installing Xcode)
prerequisites, (Installing Xcode)
setting the path, (Setting the Path)
staying organized, (Staying Organized)
terminal window, (Introducing the Command Line)

Mac OS X 10.5 (Leopard) installation, (Mac OS X 10.5 (Leopard))

Mac OS X installation, (Installing on Mac OS X)

Mac OS X text editors, (Mac OS X Text Editors)

TextMate, (Mac OS X Text Editors)
TextWrangler, (Mac OS X Text Editors)

make tool (C program), (Using rake to Migrate Our Data)

manual benchmarking, (Manual Benchmarking)

many-to-many associations, (Defining Relationships Between Objects)

map.story, (Improving the Story Randomizer)

mapping

new resources, (Mapping a New Resource)
URLs, (Resources in Rails)

MemCached Store session container, (The MemCached Store Session Container)

method calls

parentheses in, (Use of Parentheses)

method notation, (Method Notation)

methods

defined, (Ruby Is an Object Oriented Language)
in Ruby, (The Interactive Ruby Shell (irb))
object interfaces, (Classes and Objects)

migration files

class definition in, (Creating a Skeleton Migration File)
class methods, (Creating a Skeleton Migration File)
defined, (Understanding the Output)
filling in the gaps, (Creating the stories Table)
modifying the schema, (Modifying the Schema Using Migrations)
name and type of data storage, (Creating the stories Table)

migrations

creating for Vote model, (Examining the Vote Migration)
defined, (Database Tables)
to alter existing tables, (Creating the stories Table)
to generate the counter cache, (Making Room for the Cache)
to make alterations to your database, (Modifying the Schema Using Migrations)
using rake to migrate data, (Using rake to Migrate Our Data), (Applying the Migration), (Generating a User Model), (Testing a Vote’s Relationship to a User), (Applying the Migration), (Adding a Model Attribute)

mkdir command (make directory), (Staying Organized)

mod_ruby extension, (The mod_ruby Extension)

model callbacks, (Introducing Model Callbacks)

model generator, (The Model Generator)

running the generate Script, (Running the generate Script)
sample output, (Running the generate Script)
understanding the output, (Understanding the Output)
YAML, (Understanding YAML)

model testing (see testing the model)

model-view-controller (MVC) architecture, (The Model-View-Controller Architecture)

about, (Convention Over Configuration)
ActionController module, (ActionController (the Controller))
ActionPack library, (The ActionPack Module)
ActionView module, (ActionView (the View))
ActiveRecord module, (ActiveRecord (the Model))
app subdirectory, (MVC the Rails Way)
in theory, (MVC in Theory)
processing a page request, (MVC in Theory)
reasons for separating software application components, (MVC in Theory)
software application components, (MVC in Theory)
the Rails way, (MVC the Rails Way)

Model.find method, (Adding Functionality to the Controller)

modeling the user, (Modeling the User)

models

generating, (Generating a Model)
in MVC, (MVC in Theory)

Mongrel web server

about, (Starting Our Application), (Mongrel)
setting up Apache as web server for, (Setting up Apache)
use on production database, (Moving to the Production System)

mongrel_rails command, (Moving to the Production System), (Setting up Apache)

mongrel_rails restart, (The ActiveRecord Store Session Container)

MVC (see model-view-controller (MVC) architecture)

MySQL database engine

installing on Windows, (Installing on Windows)

N

namespace

acceptance by rake task, (Using rake to Migrate Our Data)

naming classes and files, (ActionController (the Controller))

naming template files, (ActionView (the View))

navigation menu, (Adding a Navigation Menu), (Expanding the Navigation Menu)

testing, (Testing the Navigation Menu)

new action

functional tests, (Writing More Functional Tests)

new_record? method, (Writing More Functional Tests)

nginx web server, (nginx)

nil (return value), (Standard Output), (nil)

Nil Class, (nil)

Numeric (class), (Numerics)

Numeric subclasses

converting a value to a Float, (Numerics)
converting a value to an Integer, (Numerics)
functionality, (Numerics)
types of numbers, (Numerics)

O

object level functionality, (Object-level Functionality)

accessor methods, (Accessor Methods)
instance methods, (Instance Methods)
instance variables, (Instance Variables)

object oriented programming, (Ruby Is an Object Oriented Language)

asking a simple question, (Ruby Is an Object Oriented Language)
passing arguments, (Ruby Is an Object Oriented Language)
sending instructions, (Ruby Is an Object Oriented Language)

object oriented programming in Ruby, (Object Oriented Programming in Ruby)

class-level functionality, (Class-level Functionality)
classes and objects, (Classes and Objects)
inheritance, (Inheritance)
object-level functionality, (Object-level Functionality)
return values, (Return Values)

object receiver, (Dot Notation)

objects, (Classes and Objects)

(see also Ruby objects)
about, (Ruby Is an Object Oriented Language)
and classes, (Ruby Is an Object Oriented Language)
and methods, (Ruby Is an Object Oriented Language), (Classes and Objects)
and tables, (Database Tables)
communication between, (Ruby Is an Object Oriented Language)
in Ruby, (The Interactive Ruby Shell (irb))
instance variables, (Instance Variables)
interface, (Classes and Objects)
relationships between, (Defining Relationships Between Objects)

one-to-many associations, (Defining Relationships Between Objects)

one-to-many relationship, (Introducing Relationships), (Introducing the has_many Clause), (Introducing the belongs_to Clause), (Understanding Polymorphic Associations)

information storage in the database, (How’s Our Schema Looking?)

one-to-one association, (Defining Relationships Between Objects)

:only parameter, (Introducing Filter Conditions)

OOP (see object oriented programming)

Open Ruby Console, (The Interactive Ruby Shell (irb))

operators

assignment operator (=), (while and until Loops)
equation operator (==), (while and until Loops)
to increment a variable (+=), (Class-level Functionality)

opinionated software, (Convention Over Configuration)

:order argument, (Retrieving Records), (Tweaking the Voting History)

ordering records in Rails, (Tweaking the Voting History)

output

from Ruby, (Standard Output)

P

package manager

apt-get, (Using a Package Manager)
for Linux, (Installing on Linux), (Using a Package Manager)
for Ruby software, (Installing RubyGems on Linux)
rpm, (Using a Package Manager)
yum, (Using a Package Manager)

page headings

testing, (Testing Page Headings)

page object, (Introducing RJS Templates), (Styling the Voting History)

page rendering

testing, (Testing Page Rendering)

paragraph element, (Writing More Functional Tests)

parameters for blocks, (Blocks)

params, (ActionView (the View))

params hash, (Saving Data to the Database), (Adding Another Controller)

params object, (Saving Data to the Database)

parentheses, (Use of Parentheses)

:partial, (Styling the Voting History)

partials (templates), (Introducing Partials)

adding voting history, (Adding Voting History)
creating, (Creating the Partial)
defined, (ActionView (the View))
modifying, (Creating the Partial)
rendering, (Modifying the View), (Creating the View)
styling the voting history, (Styling the Voting History)
tweaking the voting history, (Tweaking the Voting History)

passing data back and forth, (Passing Data Back and Forth)

passing variables between controllers and views, (Passing Data Back and Forth)

password, (Adding Functionality to the Controller)

password template, (Creating the View)

password values, (Adding Functionality to the Controller), (Testing a Successful Login)

password_field_tag helper, (Creating the View)

PATH environment variable, (Setting the Path)

period (.), (Dot Notation)

plugin script, (What Is a Plugin?)

usage instructions, (What Is a Plugin?)

plugins

acts_as_taggable, (Introducing the acts_as_taggable_on_steroids Plugin)
functions, (What Is a Plugin?)
installation, (What Is a Plugin?)
README file, (What Is a Plugin?)
what are they?, (What Is a Plugin?)

pluralize helper, (Modifying the View), (Writing an ActionView Helper)

+= operator, (Class-level Functionality)

polymorphic associations, (Understanding Polymorphic Associations)

POST, (Writing More Functional Tests), (Testing Vote Storage), (Revisiting the Rails Console)

post_with_user, (Testing Display of the Username), (Testing Story Submission)

presentation logic, (Abstracting Presentation Logic)

ActionView helpers, (Introducing ActionView Helpers)
avoiding spaghetti, (Avoiding Presentation Logic Spaghetti)
MVC principles, (ActionView (the View))

print statement, (Standard Output)

private methods, (A Word on Filter Methods)

production environment, (Three Environments)

choosing, (Choosing a Production Environment)

back-end options, (Back-end Options)
web server options, (Web Server Options)

creating the database structure, (Moving to the Production System)

does not log every database communication, (The Implications of “Production”)

implications, (The Implications of “Production”)

moving Shovell to, (Moving to the Production System)

protected controller methods, (Implementing the Voting Bin), (Introducing ActionView Helpers), (Introducing Model Callbacks)

protected methods, (A Word on Filter Methods)

protecting the form, (Protecting the Form)

abstracting code using helper_method, (Abstracting Code Using helper_method)
requiring users to log in, (Requiring Users to Log In)

protective measures, (Protective Measures)

adding a navigation menu, (Adding a Navigation Menu)
filters, (Introducing Filters)
generating a user model, (Generating a User Model)
login functionality, (Developing Login Functionality)
managing user logins, (Managing User Logins)
modeling the use, (Modeling the User)
restricting the application, (Restricting the Application)
sessions and cookies, (Introducing Sessions and Cookies)
testing user authentication, (Testing User Authentication)

protocols in resource-centric applications, (In Theory)

Prototype JavaScript library, (Remote Scripting with Prototype), (Adding Visual Effects with script.aculo.us)

prototype.js (file), (Including the JavaScript Libraries)

proxy through, (Setting up Apache)

ProxyRequests Off directive, (Setting up Apache)

public methods, (A Word on Filter Methods)

punctuation in Ruby code, (Punctuation in Ruby)

chaining statements together, (Chaining Statements Together)
dot notation, (Dot Notation)
method notation, (Method Notation)
use of parentheses, (Use of Parentheses)

puts statement, (Standard Output)

pwd command, (Introducing the Command Line)

R

RadRails (text editor), (Linux and Cross-platform Editors)

Rails, (Getting Started)

as opinionated software, (Convention Over Configuration)
built-in Ajax helpers, (Adding Visual Effects with script.aculo.us)
code generation, (Code Generation)
configuration files, (Convention Over Configuration)
conventions, (Convention Over Configuration)
debugging, (Debugging), (Debugging Your Application)
default welcome page, (Setting the Default Page)
history, (History)
installing on Linux, (Installing Rails on Linux)
installing on Mac OS X, (Installing Rails on a Mac)
installing on Mac OS X 10.5 (Leopard), (Mac OS X 10.5 (Leopard))
installing on Windows, (Installing on Windows)
integrated support for email, (ActionMailer)
log files, (Revisiting the Logs)
logging tool, (Using the Rails Logging Tool)
Prototype Javascript library, (Remote Scripting with Prototype)
sessions in, (Sessions in Rails)
supporting multiple databases in parallel, (The Database Configuration File)
testing, (Testing)
use of Ajax in web applications, (Remote Scripting with Prototype)
use of MVC architecture, (MVC the Rails Way)
visual effects with script.aculo.us, (Adding Visual Effects with script.aculo.us)
what is it?, (Introducing Ruby on Rails), (Ajax and Rails)

Rails applications

architecture, (Choosing a Production Environment)
database architecture, (The Database Configuration File)
standard directory structure, (One Directory Structure to Rule Them All)

rails command, (Creating the Standard Directory Structure), (Starting Our Application), (Understanding the Output)

Rails Console, (Revisiting the Rails Console)

about, (Using the Rails Console)
creating records, (Creating Records)
deleting records, (Deleting Records)
headless mode, (Revisiting the Rails Console)
retrieving records, (Retrieving Records)
to manage data, (Managing Data Using the Rails Console)
updating records, (Updating Records)

Rails development principles, (Development Principles)

Agile development, (Agile Development)
convention over configuration, (Convention Over Configuration)
don’t repeat yourself, (Don’t Repeat Yourself)

Rails development repository, (History)

Rails environments, (Three Environments)

development, (Three Environments)
production, (Three Environments)
testing, (Three Environments)

Rails framework, (Introducing Ruby on Rails), (History), (Getting Started), (Rails Revealed)

Rails plugins, (Rails Plugins)

Rails welcome screen, (Starting Our Application)

rake command

accepting a namespace, (Using rake to Migrate Our Data)
moving to the production system, (Moving to the Production System)
options accepted, (Using rake to Migrate Our Data)
tasks available, (Using rake to Migrate Our Data)
to create sessions table, (The ActiveRecord Store Session Container)
to execute functional tests, (Running a Functional Test)
to execute unit tests, (Running a Unit Test), (Running the Unit Tests)
to migrate data, (Using rake to Migrate Our Data), (Applying the Migration), (Generating a User Model), (Testing a Vote’s Relationship to a User), (Applying the Migration), (Adding a Model Attribute)
to revert to the previous version of the database, (Using rake to Migrate Our Data)
to run integration tests, (Running an Integration Test)
to run the complete test suite, (Running the Complete Test Suite), (Running the Full Test Suite), (Debugging using ruby-debug)
use in production environment, (Moving to the Production System), (The ActiveRecord Store Session Container)

rake test command, (Running an Integration Test)

rake test:integration command, (Using Breakpoints in a Test)

random stories

retrieving, (Pulling in a Model)

randomizer

stories, (Improving the Story Randomizer)

readers, (Accessor Methods)

Readline, (Installing Ruby on a Mac)

receiver, (Ruby Is an Object Oriented Language), (The Interactive Ruby Shell (irb))

redirect_to function, (Ensuring Graceful Degradation)

redirecting the user

about, (Redirecting the User)
testing after login, (Testing a Successful Login), (Testing Redirection After Login)

redirection after logout

testing, (Testing Redirection After Logout)

redirection logic, (Tweaking the Redirection Logic)

relationships between objects, (Introducing Relationships)

belongs_to clause, (Introducing the belongs_to Clause)
has_many clause, (Introducing the has_many Clause)

remote scripting with Prototype, (Remote Scripting with Prototype)

render, (Adding Voting History), (Styling the Voting History)

render :partial syntax, (Adding Voting History)

replace_html method, (Introducing RJS Templates)

require command, (Analyzing the Skeleton File)

resource-centric development, (The REST)

resources

declaring, (Resources in Rails)
mapping, (Mapping a New Resource)

respond_to clause, (Ensuring Graceful Degradation)

RESTful routes

adding custom actions, (Adding Custom Actions to RESTful Routes)

RESTful-style (Representational State Transfer) development, (The REST)

restricted functionality

testing, (Testing Restricted Functionality)

restricting access to story submission, (Restricting Access to Story Submission)

filter conditions, (Introducing Filter Conditions)
redirecting the user, (Redirecting the User)

restricting the application, (Restricting the Application)

associating stories with users, (Associating Stories with Users)
protecting the form, (Protecting the Form)
restricting access to story submission, (Restricting Access to Story Submission)

retrieving records, (Retrieving Records)

return values, (Ruby Is an Object Oriented Language), (The Interactive Ruby Shell (irb)), (Return Values), (Standard Output)

:return_to URL, (Redirecting the User)

return_to value, (Testing Redirection After Login)

.rhtml file extension (see .html.erb file extension)

ri command, (Arrays)

.rjs file extension, (ActionView (the View)), (Introducing RJS Templates)

(see also .js.rjs file extension)

RJS templates

about, (Introducing RJS Templates)
approaches to, (Introducing RJS Templates)
rendering, (Ensuring Graceful Degradation)
styling the voting history, (Styling the Voting History)
updating, (Updating the RJS Template)

round

use with Numeric subclasses, (Numerics)

routing configuration, (Setting the Default Page), (Adding Another Controller)

mapping URLs, (Resources in Rails)
testing, (Testing the Routing Configuration)

Ruby, (Introducing Ruby)

as object oriented language, (Ruby Is an Object Oriented Language)
as open source, object oriented scripted language, (Introducing Ruby on Rails)
as scripting language, (Ruby Is a Scripting Language)
checking version installed on Linux, (Installing Ruby on Linux)
installing on Linux, (Installing Ruby on Linux)
installing on Mac OS X 10.4 (Tiger) and earlier installation, (Installing Ruby on a Mac)
installing on Mac OS X 10.5 (Leopard), (Mac OS X 10.5 (Leopard))
installing on Windows, (Installing on Windows)
method in, (The Interactive Ruby Shell (irb))
object oriented programming in, (Object Oriented Programming in Ruby)
standard output, (Standard Output)
variables in, (Variables and Constants)

Ruby classes, (Ruby Core Classes)

Array, (Arrays)
Bignum, (Numerics)
Fixnum, (The Interactive Ruby Shell (irb)), (Numerics)
Float, (Numerics)
Hash, (Hashes)
Integer, (Numerics), (Blocks)
naming, (Database Tables)
not reloaded on each request in the production environment, (The Implications of “Production”)
Numeric, (Numerics)
object oriented programming, (Classes and Objects)
String, (Literal Objects), (Strings)
Symbols, (Symbols)

Ruby code

about, (Introducing Ruby on Rails)
embedding in HTML using ERb syntax, (ActionView (the View))
indentation of, (Instance Methods)
punctuation in, (Punctuation in Ruby)
reading and writing, (Reading and Writing Ruby Code)

Ruby control structures, (Control Structures)

Ruby files

running, (Running Ruby Files)

ruby interactive (see ri command)

Ruby interpreter, (Getting Started), (Running Ruby Files)

Ruby objects

about, (The Interactive Ruby Shell (irb)), (Classes and Objects)
interacting with, (Interacting with Ruby Objects)
literal objects, (Literal Objects)
variables and constants, (Variables and Constants)

Ruby on Rails (see Rails)

Ruby shell (see interactive Ruby shell)

ruby-debug tool, (Debugging), (Debugging using ruby-debug), (Summary)

RubyGems

installing on Linux, (Installing RubyGems on Linux)

installing on Mac OS X, (Installing RubyGems on a Mac)

confirmation of successful installation, (Installing RubyGems on a Mac)

.rxml file extension (see xml.builder file extension)

S

Save changes, (Saving Data to the Database)

save method, (Saving an Object), (Tweaking the Redirection Logic), (Examining the Vote Migration), (Introducing Model Callbacks)

saving an object, (Saving an Object)

scaffolding

to generate views, (Generating Views with Scaffolding)
what is it?, (Generating Views with Scaffolding)

scalability, (MVC in Theory)

SCGI protocol, (The SCGI Protocol)

schema, (Database Tables)

scope of variables, (Variables and Constants)

scoreboard styling, (Styling the Scoreboard)

script folder, (Code Generation)

script.aculo.us JavaScript library, (Adding Visual Effects with script.aculo.us)

scripting languages, (Scripting Languages)

performance against compiled languages, (The Great Performance Debate)

search engine friendly URLs, (Features of the Example Application)

self.down (class method), (Creating a Skeleton Migration File), (Examining the Vote Migration), (Making Room for the Cache)

self.up (class method), (Creating a Skeleton Migration File), (Making Room for the Cache)

semicolon (;), (Chaining Statements Together)

sender, (Ruby Is an Object Oriented Language), (The Interactive Ruby Shell (irb))

session container

storing ActiveRecord objects, (Adding Functionality to the Controller)
storing objects, (Sessions in Rails)

session cookies, (What’s a Session?)

session hashes, (ActionView (the View))

session name, (Sessions in Rails)

session security, (Retrieving the Current User)

session storage containers, (Alternatives for Session Storage)

ActiveRecord Store, (The ActiveRecord Store Session Container)
MemCached Store, (The MemCached Store Session Container)

session values

retrieval, (Sessions in Rails)

sessions

in Rails, (Sessions in Rails)
physical location of, (Sessions in Rails)
what are they?, (What’s a Session?)

sessions table, (The ActiveRecord Store Session Container)

SessionsController, (Creating the Controller), (Testing the Controllers), (Testing a Logout), (Testing Redirection After Logout)

setters, (Accessor Methods)

shell

ruby-debug, (Moving Around in the Shell)

shortcuts

for cryptic HTTP codes, (Writing a Functional Test)

shove it link, (Styling the Scoreboard), (Storing the Votes), (Introducing RJS Templates), (Styling the Voting History), (Tweaking the Voting History), (Requiring a Login to Vote)

"Shovell" project

allowing users to add a story description, (Expanding the Submission Form)
completed login form, (Adding Functionality to the Controller)
controllers, (ActionController (the Controller))
creating the database structure, (Moving to the Production System)
deploying, (Deploying Shovell)
directory structure, (Creating the Standard Directory Structure)
displaying the current user, (Displaying the Name of the Current User)
empty front page, (Setting the Default Page)
example of user page, (Creating the View)
final story page with voting history, (Tweaking the Voting History)
finished show action, (Displaying Our Stories)
generate model script, (Running the generate Script)
hiding the voting link from visitors, (Requiring a Login to Vote)
index page linking to story page, (Improving the Story Randomizer)
listing all stories tagged with “rails”, (Updating the Style Sheet)
login template, (Creating the View)
making a template for, (Creating the Template)
moving to the production system, (Moving to the Production System)
name of story’s submitter displayed with the story, (Displaying the Submitter)
new story form with a layout, (Adding Some Style)
providing feedback after story submission, (Retrieving Data from the Flash)
proxied through Apache, (Setting up Apache)
Rails console, (Using the Rails Console)
served by Mongrel, (Moving to the Production System)
showing a story with voting history, (Styling the Voting History)
showing a story with voting score and vote link, (Styling the Scoreboard)
story index with navigation, (Adding a Navigation Menu)
story submission form with validation output, (Improving the User Experience)
story voting bin, (Expanding the Navigation Menu)
story with auto-generated permalink, (Expanding the Submission Form)
successfully logging out of the application, (Allowing Users to Log Out)
tags display for the new story, (Assigning Our First Tags)
transferring to production system, (Moving to the Production System)
viewing stories on the front page, (Requiring a Login to Vote)

show action, (Testing Page Rendering)

show method, (ActionView (the View)), (Determining Where a Story Lives)

show template, (Adding Voting History)

show view

changing, (Giving Stories a Shove)

Showing ... string, (Writing an ActionView Helper)

showing off our stories, (Displaying Our Stories)

Simple Common Gateway Interface (SCGI) protocol, (The SCGI Protocol)

size

use with Arrays, (Arrays)
use with Hash, (Hashes)

size method, (Using a Counter Cache)

skeleton file

analyzing

controller test, (Analyzing the Skeleton File)
model test, (Analyzing the Skeleton File)

slice

use with Strings, (Strings)

software cost, (What Does All This Cost?)

source code

reloading, (Reloading Source Code)

<span> tag, (Giving Stories a Shove)

SQL statements

for development environment, (Where’s the SQL?)

SQLite database engine, (Getting Started)

installing on Mac OS X, (Installing SQLite on a Mac)

stack traces, (Three Environments), (The Implications of “Production”), (Errors by Email)

stand-alone helper, (Creating the Template)

standard directory structure

conventions, (One Directory Structure to Rule Them All)
creating, (Creating the Standard Directory Structure)

starting our application, (Starting Our Application)

stateless protocol

defined, (Identifying Individual Users)
resource-centric applications, (In Theory)

statement modifiers

if, (The if Construct)
unless, (The unless Construct)

static pages

creating, (Creating Static Pages)

stories

abstracting presentation logic, (Abstracting Presentation Logic)
adding attributes to, (Adding a Model Attribute)
adding custom actions, (Adding Custom Actions to RESTful Routes)
adding user pages, (Adding User Pages)
determining URLS and actions, (Determining Where a Story Lives)
displaying, (Displaying Our Stories)
displaying votes, (Giving Stories a Shove)
implementing clean URLs, (Implementing Clean URLs)
implementing the front page, (Implementing the Front Page)
implementing the voting bin, (Implementing the Voting Bin)
making Shove-able, (Making Stories Shove-able)
requiring that users log in to vote, (Requiring a Login to Vote)
selecting on basis of voting scores, (Promoting Popular Stories)
story randomizer, (Improving the Story Randomizer)
testing advanced functionality, (Testing the New Functionality)
testing display of by tag, (Testing the Display of Stories by Tag)
testing finding of by tag, (Testing the Finding of a Story by Tag)
viewing by tag, (Viewing Stories by Tag)
with auto-generated permalink, (Expanding the Submission Form)

Stories Controller

generating, (Running the generate Script)

stories.yml (fixture file), (Understanding the Output)

stories_controller.rb (file), (Understanding the Output)

stories_controller_test.rb (file), (Understanding the Output)

StoriesController

accessing from a browser, (Starting Our Application … Again)
modifying, (Modifying the Controller), (Requiring a Login to Vote)
testing, (Testing the StoriesController)

StoriesController class

displaying the submitter, (Displaying the Submitter)
fetch_stories method, (Manual Benchmarking)
instantiation of, (Starting Our Application … Again)
sample class definition, (ActionController (the Controller))
show method, (Determining Where a Story Lives)
storing the submitter, (Storing the Submitter)
testing redirection after logout, (Testing Redirection After Logout)
testing the controller, (Testing the Controllers)
testing the display of username, (Testing Display of the Username)

storing the votes, (Storing the Votes)

Story class

adding relationship definitions to, (Adding Relationships for the User Class)

story display page

testing, (Testing the Story Display Page)

story index pages

testing, (Testing the Story Index Pages)

@story instance variable, (Creating the Template), (Modifying the Controller)

Story Model, (Running the generate Script)

making it taggable, (Making a Model Taggable)
testing, (Testing the Model)

@story object, (Introducing the form_for Helper), (Creating the Template)

story page

testing display of tags on, (Testing the Display of Tags on a Story Page)

story partial, (Creating the View)

updating, (Updating the story Partial)

story submission, (Enabling Story Submission)

creating a form, (Creating a Form)
creating a layout, (Creating a Layout)
providing feedback after, (Retrieving Data from the Flash)
resources in Rails, (Resources in Rails)
template creation, (Creating the Template)
testing, (Testing Story Submission)
user feedback and the flash, (Enabling User Feedback with the Flash)

story submission form

allowing users to add a story description, (Expanding the Submission Form)

debugging within templates, (Debugging within Templates)

expanding, (Adding a Description to Stories)

testing, (Testing the Story Submission Form)

testing the display, (Testing the Display of the Story Submission Form)

with tags, (Assigning Our First Tags)

testing, (Testing the Submission of a New Story with Tags)

with validation output, (Improving the User Experience)

story submitter

displaying, (Displaying the Submitter)
storing, (Storing the Submitter)
testing display of, (Testing the Display of the Story Submitter)
testing storage of, (Testing Storage of the Submitter)

story submitter link text

testing, (Testing the Story Submitter Link Text)

Story.find :all, (Making Room for the Cache), (Modifying the Controller)

story.rb (file), (Understanding the Output)

@story.user, (Displaying the Submitter)

story_helper.rb (file), (Understanding the Output)

story_test.rb (file), (Understanding the Output)

story_type, (Writing an ActionView Helper)

story_url function, (Improving the Story Randomizer)

StoryTest class, (Analyzing the Skeleton File)

Story’s relationship to Vote model, (Testing a Story’s Relationship to a Vote)

String class, (Strings)

converting to Symbols, (Symbols)
literal objects, (Literal Objects)
methods, (Strings)

string literal, (Literal Objects), (Variables and Constants), (Strings)

String object, (Literal Objects), (Strings)

string objects

converting to number objects, (Converting from Strings to Numbers)

style (layouts), (Adding Some Style)

style sheet

applying to an application, (Adding Some Style)
creating the view, (Creating the View)
layout creation, (Establishing Structure)
updating, (Updating the Style Sheet)

styling

front page, (Styling the Front Page)
voting history, (Styling the Voting History)

submission form

expanding, (Expanding the Submission Form)

Submit button, (Creating the Template), (Analyzing the HTML)

submitter (see story submitter)

Subversion (version control systems), (Subversion)

:success symbol, (Writing a Functional Test)

successful login, (Testing a Successful Login)

sudo, (Installing Ruby on a Mac), (Installing Rails on Linux)

Symbols (class), (Symbols)

advantages over Strings, (Symbols)
converting to Strings, (Symbols)

T

tables, (Database Tables)

(see also database tables)
relationship with objects, (Database Tables)

Tag class, (Making a Model Taggable)

tag display

creating a tag partial, (Creating a tag Partial)
enabling, (Enabling Tag Display)
updating the story partial, (Updating the story Partial)
updating the style sheet, (Updating the Style Sheet)

tag partial, (Creating a tag Partial)

tag submission, (Enabling Tag Submission)

tag_id, (Creating a Migration for the Plugin)

tag_list, (Making a Model Taggable), (Updating the story Partial), (Testing the Submission of a New Story with Tags)

taggable_id, (Creating a Migration for the Plugin)

taggable_type, (Creating a Migration for the Plugin)

tagged stories

displaying, (Displaying Tagged Stories)
testing tag action for listing, (Testing the show Action of TagsController)

tagging, (Features of the Example Application), (Adding Tagging to Shovell)

tagging functionality

running the test suite, (Running the Test Suite ... Again!)
testing, (Testing the Tagging Functionality)
testing the controller, (Testing the Controller)
testing the model, (Testing the Model)

taggings table, (Creating a Migration for the Plugin)

tags

assigning first, (Assigning Our First Tags)
testing display of on story page, (Testing the Display of Tags on a Story Page)
testing display of stories by tag, (Testing the Display of Stories by Tag)
testing finding of stories by tag, (Testing the Finding of a Story by Tag)
viewing stories by, (Viewing Stories by Tag)

tags table, (Creating a Migration for the Plugin)

tar command, (Installing Ruby on Linux)

template files

creating, (Displaying Our Stories)
extensions, (ActionView (the View))
naming and storage, (ActionView (the View))

template rendering, (Creating the View)

testing, (Testing the Rendering of Templates)

templates

creating, (Creating the Template)
debugging within, (Debugging within Templates)
layouts, (ActionView (the View))
partials, (ActionView (the View))
stories, (Displaying Our Stories)

temporary working directory, (Staying Organized)

test-driven development (TDD), (Testing the Form)

test types, (Testing the Form)

test_should_show_index test, (Writing a Functional Test), (Writing More Functional Tests)

test_should_show_new_form, (Testing the Display of the Story Submission Form)

test_truth method, (Using Assertions), (Writing a Unit Test), (Analyzing the Skeleton File)

testing a failed login, (Testing a Failed Login)

testing a logout, (Testing a Logout)

testing a story’s relationship to a vote, (Testing a Story’s Relationship to a Vote)

testing a successful login, (Testing a Successful Login)

testing a vote’s relationship to a story, (Testing a Vote’s Relationship to a Story)

testing additions to the counter cache, (Testing Additions to the Counter Cache)

testing advanced functionality, (Testing the New Functionality)

running the complete test suite, (Running the Complete Test Suite)
testing the model, (Testing the Model)
testing the StoriesController, (Testing the StoriesController)
testing the UsersController, (Testing the UsersController)

testing Ajax voting, (Testing Ajax Voting)

testing deletions from the counter cache, (Testing Deletions from the Counter Cache)

testing display of the username, (Testing Display of the Username)

testing environment (Rails), (Three Environments)

testing page headings, (Testing Page Headings)

testing page rendering, (Testing Page Rendering)

testing redirection after login, (Testing Redirection After Login)

testing redirection after logout, (Testing Redirection After Logout)

testing regular HTTP voting, (Testing Regular HTTP Voting)

testing restricted functionality, (Testing Restricted Functionality)

testing storage of the submitter, (Testing Storage of the Submitter)

testing story submission, (Testing Story Submission)

testing the assignment of tags, (Testing the Assignment of Tags)

testing the controller, (Testing the Controller)

analyzing the skeleton file, (Analyzing the Skeleton File)
functional tests for new action, (Writing More Functional Tests)
running a functional test, (Running a Functional Test)
writing a functional test, (Writing a Functional Test)

testing the controller (tagging functionality), (Testing the Controller)

testing the display of stories by tag, (Testing the Display of Stories by Tag)
testing the display of tags on a story page, (Testing the Display of Tags on a Story Page)
testing the display of the story submission form, (Testing the Display of the Story Submission Form)
testing the submission of a new story with tags, (Testing the Submission of a New Story with Tags)
testing the tag action for listing tagged stories, (Testing the show Action of TagsController)

testing the controller (user authentication), (Testing the Controllers)

testing a failed login, (Testing a Failed Login)
testing a logout, (Testing a Logout)
testing a successful login, (Testing a Successful Login)
testing display of the username, (Testing Display of the Username)
testing redirection after login, (Testing Redirection After Login)
testing redirection after logout, (Testing Redirection After Logout)
testing storage of the submitter, (Testing Storage of the Submitter)
testing story submission, (Testing Story Submission)
testing the display of global elements, (Testing the Display of Global Elements)
testing the display of the login form, (Testing the Display of the Login Form)
testing the display of the story submitter, (Testing the Display of the Story Submitter)

testing the controller (voting functionality), (Testing the Controller)

testing Ajax voting, (Testing Ajax Voting)
testing page rendering, (Testing Page Rendering)
testing regular HTTP voting, (Testing Regular HTTP Voting)
testing vote storage, (Testing Vote Storage)

testing the creation of the initial vote, (Testing the Creation of the Initial Vote)

testing the display of global elements, (Testing the Display of Global Elements)

testing the display of stories by tag, (Testing the Display of Stories by Tag)

testing the display of tags on a story page, (Testing the Display of Tags on a Story Page)

testing the display of the login form, (Testing the Display of the Login Form)

testing the display of the story submission form, (Testing the Display of the Story Submission Form)

testing the display of the story submitter, (Testing the Display of the Story Submitter)

testing the finding of a story by tag, (Testing the Finding of a Story by Tag)

testing the form, (Testing the Form)

controller testing, (Testing the Controller)
model testing, (Testing the Model)
running the complete test suite, (Running the Complete Test Suite)

testing the join model relationship, (Testing the Join Model Relationship)

testing the model, (Testing the Model)

analyzing the skeleton file, (Analyzing the Skeleton File)
new functionality, (Testing the Model)
running a unit test, (Running a Unit Test)
user authentication, (Testing the Model)
using assertions, (Using Assertions)
writing a unit test, (Writing a Unit Test)

testing the model (tagging functionality), (Testing the Model)

testing the assignment of tags, (Testing the Assignment of Tags)
testing the finding of a story by tag, (Testing the Finding of a Story by Tag)

testing the model (voting functionality), (Testing the Model)

preparing the fixtures, (Preparing the Fixtures)
running the unit tests, (Running the Unit Tests)
testing a story’s relationship to a vote, (Testing a Story’s Relationship to a Vote)
testing a vote’s relationship to a story, (Testing a Vote’s Relationship to a Story)
testing the voting history order, (Testing the Voting History Order)

testing the navigation menu, (Testing the Navigation Menu)

testing the rendering of templates, (Testing the Rendering of Templates)

testing the routing configuration, (Testing the Routing Configuration)

testing the StoriesController, (Testing the StoriesController)

testing the story display page, (Testing the Story Display Page)

testing the story index pages, (Testing the Story Index Pages)

testing the story submission form, (Testing the Story Submission Form)

testing the story submitter link text, (Testing the Story Submitter Link Text)

testing the submission of a new story with tags, (Testing the Submission of a New Story with Tags)

testing the tag action for listing tagged stories, (Testing the show Action of TagsController)

testing the tagging functionality, (Testing the Tagging Functionality)

testing the UsersController, (Testing the UsersController)

testing the VotesController, (Testing the VotesController)

testing the voting functionality, (Testing the Voting Functionality)

controller testing, (Testing the Controller)
model testing, (Testing the Model)
running the full test suite, (Running the Full Test Suite)

testing the voting history order, (Testing the Voting History Order)

testing user authentication, (Testing User Authentication)

testing user voting history, (Testing User Voting History)

testing vote storage, (Testing Vote Storage)

testing your application, (Testing Your Application)

integration tests, (Integration Tests)
using breakpoints, (Using Breakpoints in a Test)

tests (of assertions), (Using Assertions)

text editors, (Which Text Editor?)

ConTEXT, (Windows Text Editors)
cross-platform, (Linux and Cross-platform Editors)
Emacs, (Linux and Cross-platform Editors)
jEdit, (Linux and Cross-platform Editors)
Linux, (Linux and Cross-platform Editors)
Mac OS X, (Mac OS X Text Editors)
RadRails, (Linux and Cross-platform Editors)
TextMate, (Mac OS X Text Editors)
TextWrangler, (Mac OS X Text Editors)
UltraEdit, (Windows Text Editors)
Vim, (Linux and Cross-platform Editors)

text_area helper, (Expanding the Submission Form)

text_field method, (Introducing the form_for Helper)

text_field_tag, (Creating the View), (Modifying the View)

textarea element, (Expanding the Submission Form)

TextMate (text editor), (Mac OS X Text Editors), (TextMate Integration)

textual identifiers, (Symbols)

TextWrangler (text editor), (Mac OS X Text Editors)

37signals, (History)

tilde, (Introducing the Command Line)

times method of an Integer object, (Blocks)

timing values (log files), (Revisiting the Logs)

title of the story, (Creating the Partial)

to_formatted_s, (Styling the Voting History)

U

UltraEdit (text editor), (Windows Text Editors)

unit tests

about, (Testing the Form)
error information, (Running a Unit Test)
failed test, (Running a Unit Test)
running, (Running a Unit Test), (Running the Unit Tests), (Running the Unit Tests)
successful test, (Running a Unit Test)
writing, (Writing a Unit Test)

unless condition, (Displaying the Name of the Current User)

unless construct, (The unless Construct)

unless statement modifier, (The unless Construct)

until, (while and until Loops)

up method, (Creating a Skeleton Migration File)

upcase method, (Method Notation)

update_attribute method, (Updating Records), (Making Room for the Cache)

:updated_at, (Examining the Vote Migration)

updating records, (Updating Records)

upto method of an Integer object, (Blocks)

URLs

mapping to controllers and actions, (Resources in Rails)
for stories, (Determining Where a Story Lives), (Implementing Clean URLs)

URLs in resource-centric applications, (In Theory)

user authentication, (Testing User Authentication)

running the full test suite, (Running the Full Test Suite)
testing the controllers, (Testing the Controllers)
testing the model, (Testing the Model)

User class, (Adding Relationships for the User Class)

adding relationships to, (Adding Relationships for the User Class)

user feedback, (Improving the User Experience)

information on type and place of error, (Improving the User Experience)
validation errors, (Improving the User Experience)

user log out, (Allowing Users to Log Out)

user logins, (Managing User Logins)

allowing users to log out, (Allowing Users to Log Out)
displaying the name of the current user, (Displaying the Name of the Current User)
retrieving the current user, (Retrieving the Current User)

user model, (Introducing the has_many :through Association)

adding relationships to the User class, (Adding Relationships for the User Class)

creating a User, (Creating a User)

database table creation, (Generating a User Model)

generating, (Generating a User Model)

testing a user's relationship to a story, (Testing a User’s Relationship to a Story)

testing authentication, (Testing the Model)

preparing the fixtures, (Preparing the Fixtures)
running the unit tests, (Running the Unit Tests)
testing a story’s relationship to a user, (Testing a Story’s Relationship to a User)
testing a user’s relationship to a story, (Testing a User’s Relationship to a Story)
testing a user’s relationship to a vote, (Testing a User’s Relationship to a Vote)
testing a vote’s relationship to a user, (Testing a Vote’s Relationship to a User)

User object

adding functionality to the controller, (Adding Functionality to the Controller)
creating, (Creating a User)
modifying the controller, (Adding Another Controller)

user pages

adding, (Adding User Pages)
creating the view, (Creating the View)
has_many :through association, (Introducing the has_many :through Association)
join model relationship, (Introducing the Join Model Relationship)
modifying the controller, (Adding Another Controller)

user registration system, (Features of the Example Application)

user voting history

testing, (Testing User Voting History)

username

adding functionality to the controller, (Adding Functionality to the Controller)
creating the view, (Creating the View)
testing display of, (Testing Display of the Username)

users

associating stories with, (Associating Stories with Users)
necessity to log in to vote, (Requiring a Login to Vote)
redirecting, (Redirecting the User)
requiring them to log in, (Requiring Users to Log In)

UsersController, (Adding Another Controller)

testing, (Testing the UsersController)

V

validation errors, (Improving the User Experience)

validations, (Tweaking the Redirection Logic)

and redirection logic, (Tweaking the Redirection Logic)
applying, (Applying Validations)

values

use with Hash, (Hashes)

variables, (Variables and Constants)

class, (Class-level Functionality)
global, (Variables and Constants)
instance, (Object-level Functionality), (Instance Variables)
scope of, (Variables and Constants)

verbs, (In Theory), (REST and the Web), (REST in Rails)

version control systems, (Version Control and Deployment Management)

version numbers of installed components, (Starting Our Application)

vertical bars (|)

placement before blocks, (Blocks)

view template

filling in, (Filling in the View Template)

viewing stories by tag

displaying tagged stories, (Displaying Tagged Stories)
filling in the view template, (Filling in the View Template)
modifying the controller, (Creating the Controller)

views

communication with controllers via instance variables, (ActionView (the View))
creating, (Creating a View), (Creating the View)
creating dynamic pages, (Creating Dynamic Pages)
creating static pages, (Creating Static Pages)
generating with scaffolding, (Generating Views with Scaffolding)
modifying, (Modifying the View), (Modifying the View), (Modifying the View)
in MVC, (MVC in Theory)
passing data back and forth, (Passing Data Back and Forth)
pulling in a model, (Pulling in a Model)

Vim (text editor), (Linux and Cross-platform Editors)

visual effects with script.aculo.us, (Adding Visual Effects with script.aculo.us)

Vote class

adding relationship definitions to, (Adding Relationships for the User Class)

Vote class definition, (Introducing the belongs_to Clause)

Vote model, (Tweaking the Voting History)

applying the migration, (Applying the Migration)
association with Story model, (Introducing Relationships), (Introducing the has_many Clause), (Introducing the belongs_to Clause), (How’s Our Schema Looking?)
creating the migration, (Examining the Vote Migration)
creating the model, (Creating the Model)
generating, (Generating a Vote Model)
relationship to a story, (Testing a Vote’s Relationship to a Story)

Vote object, (Introducing the has_many Clause), (Testing the Voting History Order), (Using a Counter Cache), (Making Room for the Cache)

vote storage

testing, (Testing Vote Storage)

votes

auto-voting for newly submitted stories, (Auto-voting for Newly Submitted Stories)
controlling where they go, (Controlling Where the Votes Go)
displaying, (Giving Stories a Shove)
incremented when a new vote is added, (Testing Additions to the Counter Cache)
need to reload database when votes added, (Testing Additions to the Counter Cache)
storing, (Storing the Votes)

votes method, (Introducing the has_many Clause), (Testing a Story’s Relationship to a Vote), (Requiring a Login to Vote)

votes_count, (Making Room for the Cache), (Modifying the Controller), (Testing Additions to the Counter Cache), (Testing Deletions from the Counter Cache), (Preparing the Fixtures)

VotesController

testing, (Testing the VotesController)

VotesController class

graceful degradation, (Ensuring Graceful Degradation)

voting bin, (Implementing the Voting Bin)

voting functionality

testing, (Testing the Voting Functionality)
testing the controller, (Testing the Controller)
testing the model, (Testing the Model)

voting history

adding, (Adding Voting History)
styling, (Styling the Voting History)
testing the order, (Testing the Voting History Order)
tweaking, (Tweaking the Voting History)

voting scores

selecting stories on basis of, (Promoting Popular Stories)

W

Web 2.0

adding tagging, (Adding Tagging to Shovell)
and Ajax, (Introducing Ajax)

web application

definition, (Introducing Ruby on Rails)

Web applications

and REST, (REST and the Web)

web browsers

not supporting Ajax, (Adding Visual Effects with script.aculo.us)

web server options, (Web Server Options)

WEBrick web server, (Starting Our Application)

(see also Mongrel web server)

while loops, (while and until Loops)

Windows firewall, (Installing on Windows)

Windows installation, (Installing on Windows)

Windows text editors

ConTEXT, (Windows Text Editors)
UltraEdit, (Windows Text Editors)

writers, (Accessor Methods)

X

Xcode

installing, (Installing Xcode)

XcodeTools.mpkg, (Installing Xcode)

.xml.builder file extension, (ActionView (the View))

xml_http_request method, (Testing Ajax Voting)

XmlHttpRequest object, (Introducing Ajax)

Y

YAML, (Understanding YAML), (Debugging within Templates)
YAML file, (Understanding YAML)
yield command, (Establishing Structure)

Z

zero?

use with Numeric subclasses, (Numerics)

About SitePoint

SitePoint specializes in publishing fun, practical and easy-to-understand content for Web professionals. Visit sitepoint.com to access our books, newsletters, articles and community forums.