Index

A note on the digital index

A link in an index entry is displayed as the section title in which that entry appears. Because some sections have multiple index markers, it is not unusual for an entry to have several links to the same section. Clicking on any link will take you directly to the place in the text in which the marker appears.

Symbols

#{}, in strings, Getting and Putting Input
$!, rescue: Execute Code When Error Occurs
$', Prematch and Postmatch
$:, Including Modules from Files
$`, Prematch and Postmatch
$˜, Prematch and Postmatch
%/, User-Defined String Delimiters
%d, Format Strings, Format Strings
%f, Format Strings, Format Strings
%o, Format Strings, Format Strings
%p, Format Strings, Format Strings
%Q, User-Defined String Delimiters, User-Defined String Delimiters
%q, User-Defined String Delimiters, User-Defined String Delimiters
%r, Making Matches, Making Matches
%s, Format Strings, Format Strings
%W, Iterating with a Range, Iterating with a Range, Creating Arrays, Creating Arrays
%w, Creating Arrays, Creating Arrays
%x, Backquotes, Backquotes, Format Strings, Format Strings
(), parentheses,, Getting and Putting Input, Superclasses and Subclasses, Attribute Readers and Writers, if..then..else, if..then..else, Parallel Assignment, Parallel Assignment, Block or Hash?, Block or Hash?, File Operations
and super, Superclasses and Subclasses
avoiding ambiguity, if..then..else, Parallel Assignment, Block or Hash?
in regular expressions, File Operations
optional, Getting and Putting Input, Attribute Readers and Writers
*?, File Operations
+=, Class Variables
+?, File Operations
3rd Rail, Ruby and Rails Development Software
<%=. See Rails, tags, if..then..else, Parallel Assignment, Block or Hash?
<<, Concatenation, Concatenation, Iterating with a Range, Hash Methods, Hash Methods, Singleton Classes, Public, Protected, and Private Methods, The One-Way-In, One-Way-Out Principle, The One-Way-In, One-Way-Out Principle, Modifying Receivers and Yielding New Objects
and singletons, Singleton Classes, Public, Protected, and Private Methods
append operator, Concatenation, Hash Methods, The One-Way-In, One-Way-Out Principle
concatenation method, Modifying Receivers and Yielding New Objects
with heredocs, Iterating with a Range
<<-, with heredocs, Iterating with a Range
===, if..elsif, The === Method
=begin, Comments, Comments
=begin rdoc, Documenting Ruby with RDoc, Documenting Ruby with RDoc
=end, Comments, Comments, Documenting Ruby with RDoc, Documenting Ruby with RDoc
=˜, Making Matches
?..:, as shorthand for if..then..else, if..elsif, Ensuring That a Thread Executes
B, File Operations, File Operations
, File Operations, File Operations
D, File Operations, File Operations
d, File Operations, File Operations
S, File Operations, File Operations
s, File Operations, File Operations
W, File Operations, File Operations
w, File Operations, File Operations

A

accessor methods, Accessor Methods
Ada, What Is Ruby?
Adobe Flex, Test It!
alias, Alias Methods
all_symbols, Why Use Symbols?
ambiguity, Matters of Ruby Style, Returning Values, Block or Hash?, Alias Methods, IRB: Interactive Ruby, Unit Testing
avoiding, Returning Values, Alias Methods
hashes and blocks, Block or Hash?
line breaks, IRB: Interactive Ruby, Unit Testing
& (ampersand), Passing Named Proc Arguments, Passing Named Proc Arguments
ampersand (&), Passing Named Proc Arguments, Passing Named Proc Arguments
ancestors. See class hierarchy, if..then..else, Alternative Case Syntax
&& (and operator), if..then..else, Alternative Case Syntax
and operator (&&), if..then..else, Alternative Case Syntax
Apache, A First Ruby on Rails Application, Web Servers
Aptana RadRails, IDEs and Editors
arguments, Default and Multiple Arguments, The One-Way-In, One-Way-Out Principle, The One-Way-In, One-Way-Out Principle, Parallel Assignment, Parallel Assignment
by reference, The One-Way-In, One-Way-Out Principle
by value, Parallel Assignment
default, Default and Multiple Arguments
passing, Parallel Assignment
arrays, Arrays and Hashes, Arrays, Arrays, Creating Arrays, Creating Arrays, Creating Arrays, Multidimensional Arrays, Multidimensional Arrays, Iterating over Arrays, Iterating over Arrays, Indexing into Arrays, Indexing into Arrays, Copying Arrays, Sorting Arrays, Comparing Values, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Array Methods, Hash Methods, Hash Methods, Hash Methods, Look Familiar?, Blocks and Arrays, Blocks and Arrays, Why Use Symbols?
&, Array Methods
+, Array Methods
-, Array Methods
<<, Array Methods
appending, Hash Methods
clear, Array Methods
clone, Copying Arrays
collect, Blocks and Arrays, Why Use Symbols?
compact, Array Methods, Array Methods
compact!, Array Methods
concatenating, Hash Methods
copying, Indexing into Arrays
creating, Arrays
delete, Array Methods
delete_at, Array Methods
each, Blocks and Arrays
expressions in, Creating Arrays
flatten, Array Methods, Array Methods
flatten!, Array Methods
indexing, Iterating over Arrays
iterators, Iterating over Arrays, Look Familiar?
length, Arrays
methods, Comparing Values
multidimensional, Multidimensional Arrays
nested, Multidimensional Arrays
of filenames, Creating Arrays
of strings, Creating Arrays
reverse, Array Methods
reverse!, Array Methods
sort, Array Methods
sort!, Array Methods
sorting, Sorting Arrays
testing for equality, Indexing into Arrays
treating hashes as, Hash Methods
ASCII character codes, testing, Opening and Closing Files
assert, Unit Testing, Unit Testing
assert_block, Unit Testing
assert_equal, Debugging, Unit Testing
assert_instance_of, Unit Testing
assert_in_delta, Unit Testing
assert_kind_of, Unit Testing
assert_match, Unit Testing
assert_nil, Unit Testing
assert_nothing_raised, Unit Testing
assert_nothing_thrown, Unit Testing
assert_not_equal, Unit Testing
assert_not_nil, Unit Testing
assert_not_same, Unit Testing
assert_no_match, Unit Testing
assert_operator, Unit Testing
assert_raise, Unit Testing
assert_raises, Unit Testing
assert_respond_to, Unit Testing
assert_same, Unit Testing
assert_send, Unit Testing
assert_thrown, Unit Testing
= (assignment operator), Local and Global Variables
assignment operator (=), Local and Global Variables
assignments, Parallel Assignment, Parallel Assignment, Parallel Assignment
multiple, Parallel Assignment
parallel, Parallel Assignment
=> (assoc operator), rescue: Execute Code When Error Occurs
assoc operator (=>), rescue: Execute Code When Error Occurs
associative arrays. See hashes, rescue: Execute Code When Error Occurs
* (asterisk), Making Matches, File Operations
asterisk (*), Making Matches, File Operations
@ (at sign), Attribute Readers and Writers, Class Variables
at sign (@), Attribute Readers and Writers, Class Variables
attributes, Attribute Readers and Writers
attr_accessor, Attribute Readers and Writers, Self-Modifying Programs
attr_reader, Attribute Readers and Writers, Symbols
attr_writer, Attribute Readers and Writers, Symbols

B

backquotes. See strings, raise: Reactivate a Handled Error
backtrace, raise: Reactivate a Handled Error
BasicObject, Class Variables, Singleton Methods, rescue: Execute Code When Error Occurs
begin..end, while Modifiers, raise: Reactivate a Handled Error
bindings, Creating Classes at Runtime
block parameters, Blocks and Block Parameters, Nameless Functions, Passing Named Proc Arguments, Passing Named Proc Arguments, Blocks as Iterators
blocks, Testing Arrays for Equality, for Loops, Blocks and Block Parameters, Blocks and Block Parameters, Blocks and Block Parameters, Blocks, Procs, and Lambdas, Blocks, Procs, and Lambdas, What Is a Block?, Nameless Functions, Look Familiar?, Look Familiar?, Blocks and Arrays, Creating Objects from Blocks, Creating Objects from Blocks, yield, yield, Passing Named Proc Arguments, Passing Named Proc Arguments, Passing Named Proc Arguments, Precedence Rules, Blocks as Iterators, Blocks as Iterators, Blocks as Iterators, Blocks as Iterators, Blocks as Iterators, Blocks as Iterators, Blocks as Iterators, Adding Variables and Methods, send
and for loops, Blocks as Iterators
and instance variables, Blocks as Iterators
and iterating arrays, Look Familiar?
and line breaks, What Is a Block?
and local variables, Blocks as Iterators
as iterators, Blocks as Iterators
call, Creating Objects from Blocks
creating methods from, Adding Variables and Methods, send
creating objects from, Creating Objects from Blocks
do..end, Blocks and Block Parameters, Look Familiar?
nested, yield
parameters, Blocks and Block Parameters, Nameless Functions, Passing Named Proc Arguments, Passing Named Proc Arguments, Blocks as Iterators
passing as named arguments, yield
precedence, Precedence Rules
returning from methods, Blocks as Iterators
Ruby 1.9, Blocks, Procs, and Lambdas
scope of, Passing Named Proc Arguments, Blocks as Iterators
sorting with, Testing Arrays for Equality
{}, for Loops, Blocks and Arrays
block_given?, Precedence Rules
blogs, Let’s Make a Blog!
books, on Ruby, Further Reading
Boolean operators, if..then..else, Negation, Alternative Case Syntax, Alternative Case Syntax, Alternative Case Syntax
negation, Negation
precedence, Alternative Case Syntax
side effects, Alternative Case Syntax
break, loop, Case Statements, Nameless Functions
breaking code over a line, Unit Testing
breakpoints, Debugging
build_message, Unit Testing
bytes, reading, Marshal and Singletons

C

call, Symbols and Variables
camel case, Matters of Ruby Style
capitalization. See strings, Making Matches, File Operations
^ (caret), Making Matches, File Operations
caret (^), Making Matches, File Operations
case sensitivity, Getting and Putting Input
case statements, if and unless Modifiers, Case Statements, The === Method
return values, The === Method
selectors, Case Statements
catch, Alternative Case Syntax, raise: Reactivate a Handled Error
character codes. See strings, Removing Newline Characters: chop and chomp
chomp, Removing Newline Characters: chop and chomp
chop, Removing Newline Characters: chop and chomp
class hierarchy, Class Hierarchies, Attributes, and Class Variables
class methods, Class Methods, What Are Class Methods For?, Summarizing Instance, Class, and Singleton Methods
@@ (class variables), Attribute Readers and Writers, Attribute Readers and Writers, Class Variables, Class Variables
classes, Classes and Objects, Class Variables, Class Variables, Class Variables, Singleton Methods, Singleton Methods, A Module Is Like a Class . . ., Including Modules from Files
as objects, Class Variables
descending from Object, Singleton Methods
open, Class Variables
partial, Class Variables
singleton, Singleton Methods
vs. modules, A Module Is Like a Class . . ., Including Modules from Files
class_eval, Special Types of eval
class_variables, Adding Variables and Methods
class_variable_get, Adding Variables and Methods
class_variable_set, Adding Variables and Methods
clone, Copying a Hash
closures, What Is a Closure?
collect, loop, Mutexes
: (colon), if..then..else, Case Statements, Case Statements, Symbols
in case statements, Case Statements
in symbols), Symbols
instead of then, if..then..else
colon (:), if..then..else, Case Statements, Case Statements, Symbols
in case statements, Case Statements
in symbols, Symbols
instead of then, if..then..else
comments, Introduction, Comments, Comments, Comments
in code examples, Introduction
multiline, Comments
single line, Comments
Comparable, Comparing Values, Including Modules from Files, Including Modules from Files
<=> (comparison operator), Testing Arrays for Equality, Sorting Arrays, loop, Including Modules from Files, Sorting by Size
comparison operator (<=>), Testing Arrays for Equality, Sorting Arrays, loop, Including Modules from Files, Sorting by Size
conditional statements, Conditional Statements
constants, Class Variables, Class Variables, Case Statements, Including Modules from Files, Including Modules from Files
accessing with ::, Class Variables, Including Modules from Files, Including Modules from Files
inside classes, Class Variables
constructors, Messages, Methods, and Polymorphism, Constructors: new and initialize, Constructors: new and initialize, Class Variables, Class Variables, Ruby Constructors: new or initialize?, Ruby Constructors: new or initialize?
initialize, Constructors: new and initialize, Ruby Constructors: new or initialize?
new, Constructors: new and initialize, Ruby Constructors: new or initialize?
overriding, Class Variables
const_get, Adding Variables and Methods
const_set, Creating Classes at Runtime
Controller, Create a Controller, Test It!
copying files, Characters and Compatibility
cp, Copying Files
{} (curly brackets), Blocks and Arrays, Blocks and Arrays, File Operations
as delimiters, Blocks and Arrays
in regular expressions, File Operations
curly brackets, {}, Blocks and Arrays, Blocks and Arrays, File Operations
as delimiters, Blocks and Arrays
in regular expressions, File Operations
custom comparisons, loop

D

data hiding, The One-Way-In, One-Way-Out Principle
databases, IDEs and Editors
debuggers, visual, Sorting by Size, Unit Testing, Ruby and Rails Development Software
debugging, IRB: Interactive Ruby, Debugging, Debugging, Debugging
breakpoints, Debugging
watchpoints, Debugging
with Ruby Debugger, Debugging
def, Local and Global Variables
default, Indexing into a Hash
default=, Indexing into a Hash
defined?, Blocks as Iterators
define_method, Why Use Symbols?, Special Types of eval, Removing Methods
delete, Hash Methods
// (delimiters), Making Matches
descendants, Class Hierarchies, Attributes, and Class Variables
destructors, Constructors: new and initialize
dictionaries. See hashes, Parallel Assignment
Digging Deeper, Class Variables, Iterating with a Range, Iterating with a Range, Hash Methods, Hash Methods, loop, loop, loop, Alternative Case Syntax, Alternative Case Syntax, Public, Protected, and Private Methods, Parallel Assignment, Parallel Assignment, Parallel Assignment, Parallel Assignment, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, Blocks as Iterators, Why Use Symbols?, Including Modules from Files, Including Modules from Files, Including Modules from Files, Including Modules from Files, Sorting by Size, Adventures in YAML, Marshal and Singletons, File Operations, File Operations, Fibers, Unit Testing, Unit Testing, Unit Testing, Unit Testing, Test It!, Test It!, Test It!, Exploring Further
arguments, passing, Parallel Assignment
arrays, Hash Methods
assertions, Unit Testing
assignments, Parallel Assignment
begin..end, raise: Reactivate a Handled Error
blocks and closures, Blocks as Iterators
Boolean operators, Alternative Case Syntax
catch..throw, Alternative Case Syntax, raise: Reactivate a Handled Error
debuggers, Unit Testing
each, loop
Enumerable, loop
equality, testing for, Parallel Assignment
exceptions, raise: Reactivate a Handled Error
extending objects, Including Modules from Files
freezing objects, Including Modules from Files, Exploring Further
hashes, Hash Methods
heredocs, Iterating with a Range
line breaks, Unit Testing
Marshal version numbers, Marshal and Singletons
method accessibility, Public, Protected, and Private Methods
modules, Including Modules from Files
MVC, Test It!
Rails folders, Test It!
recursions, Sorting by Size
regular expressions, File Operations
Ruby frameworks, Test It!
scope resolution, Including Modules from Files
string literals, Iterating with a Range
superclasses, Class Variables
symbols, Why Use Symbols?, File Operations
threads, Fibers
unit testing, Unit Testing
YAML, Adventures in YAML
yield, loop
Dir.foreach, A Discursion into Recursion
Dir.getwd, ensure: Execute Code Whether or Not an Error Occurs
directories, navigating in, Directory Inquiries
do, for Loops, What Is a Block?
do..end, What Is a Block?, Look Familiar?
documenting Ruby. See RDoc, What Is a Block?, Nameless Functions
$ (dollar sign), Making Matches, File Operations
dollar sign ($), Making Matches, File Operations
downto, Iterating upto and downto
dynamic programming, Symbols and Variables, Dynamic Programming, Dynamic Programming, Dynamic Programming, Self-Modifying Programs, eval, Special Types of eval, Adding Variables and Methods, Adding Variables and Methods, Adding Variables and Methods, send, send, Handling Missing Methods, Exploring Further
adding methods, send
adding methods to classes, Adding Variables and Methods
and embedded evaluation, Dynamic Programming
creating classes at runtime, Adding Variables and Methods
creating objects at runtime, Adding Variables and Methods
eval, Self-Modifying Programs
freezing objects, Exploring Further
monkey patching, Special Types of eval
removing methods, send
self-modifying programs, Dynamic Programming, eval
writing programs at runtime, Handling Missing Methods

E

each, for Loops, for Loops, loop, loop, Blocks and Arrays, Multiple Documents, One File
and yield, loop
vs. for, for Loops
ebooks, on Ruby, Ebooks
editors, Ruby, Ruby and Rails Development Software
Eiffel, What Is Ruby?, Classes and Objects
else, else: Execute Code When No Error Occurs
Embedded Ruby (ERb), Rails Tags, Rails Tags
encapsulation, Retrieving Data from an Object, The One-Way-In, One-Way-Out Principle, Modifying Receivers and Yielding New Objects, Adding Variables and Methods
breaking, Modifying Receivers and Yielding New Objects, Adding Variables and Methods
end, Testing a Condition: if..then
ensure, ensure: Execute Code Whether or Not an Error Occurs
Enumerable, loop, loop, loop, loop, loop, loop, loop, loop, Including Modules from Files
collect, loop
include?, loop
including in a class, loop
max, loop
min, loop, loop
overriding methods, loop
== (equal-to operator), Comparing Values, Parallel Assignment
equal-to operator (==), Comparing Values, Parallel Assignment
equal?, Parallel Assignment, Parallel Assignment, Symbols and Strings
equality, testing for, Parallel Assignment
ERb (Embedded Ruby), Create a View, Rails Tags
Errno, Error Numbers
eval, Symbols and Variables, Self-Modifying Programs
example programs, Matters of Ruby Style
exception hierarchy, rescue: Execute Code When Error Occurs
exceptions, Exception Handling, Exception Handling, rescue: Execute Code When Error Occurs, rescue: Execute Code When Error Occurs, rescue: Execute Code When Error Occurs, rescue: Execute Code When Error Occurs, rescue: Execute Code When Error Occurs, rescue: Execute Code When Error Occurs, ensure: Execute Code Whether or Not an Error Occurs, else: Execute Code When No Error Occurs, Error Numbers, retry: Attempt to Execute Code Again After an Error, retry: Attempt to Execute Code Again After an Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, raise: Reactivate a Handled Error, Exploring Further
and $!, rescue: Execute Code When Error Occurs
associating with variable name, rescue: Execute Code When Error Occurs
backtrace, raise: Reactivate a Handled Error
begin..end, omitting, raise: Reactivate a Handled Error
creating custom messages for, raise: Reactivate a Handled Error
custom, raising, raise: Reactivate a Handled Error
displaying as strings, retry: Attempt to Execute Code Again After an Error
else, else: Execute Code When No Error Occurs
ensure, ensure: Execute Code Whether or Not an Error Occurs
Errno constants, Error Numbers
multiple, rescue: Execute Code When Error Occurs
NoMethodError, rescue: Execute Code When Error Occurs
raise, raise: Reactivate a Handled Error
rescue, Exception Handling
retry, retry: Attempt to Execute Code Again After an Error
RuntimeError, raise: Reactivate a Handled Error
subclassing, raise: Reactivate a Handled Error
TypeError, rescue: Execute Code When Error Occurs, Exploring Further
ZeroDivisionError, rescue: Execute Code When Error Occurs
! (exclamation mark), if..then..else, and, or, and not, Alternative Case Syntax, Modifying Receivers and Yielding New Objects, Modifying Receivers and Yielding New Objects
as not operator, if..then..else, and, or, and not, Alternative Case Syntax
at end of methods, Modifying Receivers and Yielding New Objects
exclamation mark (!), if..then..else, and, or, and not, Alternative Case Syntax, Modifying Receivers and Yielding New Objects, Modifying Receivers and Yielding New Objects
as not operator, if..then..else, and, or, and not, Alternative Case Syntax
at end of methods, Modifying Receivers and Yielding New Objects
extend, Including Modules from Files

F

fibers, Mutexes, Mutexes, Fibers, Fibers, Fibers, Fibers, Fibers, Fibers, Fibers
alive?, Fibers
and blocks, Mutexes
and threads, Mutexes
dead, Fibers
FiberError, Fibers
parameters, Fibers
resume, Fibers
yield, Fibers
File methods, Class Methods
files, Files and IO, Files and IO, Files and IO, Opening and Closing Files, Opening and Closing Files, Opening and Closing Files, Opening and Closing Files, Characters and Compatibility, Files and Directories, Files and Directories, Directory Inquiries, Directory Inquiries, Directory Inquiries, A Discursion into Recursion, A Discursion into Recursion, Nested Sequences, Match Groups, String Methods, String Methods, File Operations
and directories, Files and Directories
as a subclass of IO, Files and IO
backing up, Directory Inquiries
closing, Files and IO
copying, Characters and Compatibility
eof, Opening and Closing Files
exist?, Files and Directories
foreach, Match Groups, String Methods
handles, Opening and Closing Files
modes, Opening and Closing Files
opening, Files and IO
processing using regular expressions, String Methods
reading/writing text, Opening and Closing Files, File Operations
saving data to YAML, Nested Sequences
size of, Directory Inquiries, A Discursion into Recursion, A Discursion into Recursion
calculating, Directory Inquiries
sorting by, A Discursion into Recursion
FileTest, Including Modules from Files
FileUtils, Copying Files
Fixnums, Parallel Assignment
flunk, Unit Testing
for loops, Loops and Iterators, for Loops, Iterating upto and downto, Iterating upto and downto, Blocks as Iterators, Blocks as Iterators
and arrays, Iterating upto and downto
and blocks, Blocks as Iterators
and local variable scoping, Blocks as Iterators
and multiple iterator arguments, Iterating upto and downto
and ranges, for Loops
for..in loops, Iterating over Arrays
foreach, Files and IO
format strings, Format Strings
freeze, Including Modules from Files, Exploring Further
frozen?, Including Modules from Files, Exploring Further
functions, Nameless Functions, Including Modules from Files
and module_function, Including Modules from Files

G

garbage collection, Constructors: new and initialize
GC, Including Modules from Files
Gemfile, Partials
Gems, Ruby, Ruby on Rails
generate, Create a Controller
getc, Characters and Compatibility, Marshal and Singletons
global variables, Testing a Condition: if..then, Symbols and Strings
goto, Alternative Case Syntax
> (greater-than sign), Comparing Values

H

Hansson, David Heinemeier, Let’s Make a Blog!
hashes, Array Methods, Hashes, Indexing into a Hash, Indexing into a Hash, Indexing into a Hash, Hash Order, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Blocks and Arrays, Sorting by Size, Converting to YAML
and curly brackets, Blocks and Arrays
copying, Indexing into a Hash
creating, Hashes
has_key?, Hash Methods
has_value?, Hash Methods
indexing into, Indexing into a Hash
items in, Hash Methods, Hash Methods, Hash Methods
deleting, Hash Methods
finding position of, Hash Methods
merging, Hash Methods
methods, Hash Methods
order of elements, Indexing into a Hash, Converting to YAML
sort, Sorting by Size
sorting, Hash Order
treating as arrays, Hash Methods
# (hask mark), for comments, Comments
hask mark (#), for comments, Comments
heredocs, Iterating with a Range
HTML, tags, Anatomy of a Simple Rails Application, Create a View

I

id2name, Symbols and Variables
IDEs (integrated development environments), Debugging and Testing, Ruby and Rails Development Software
if modifiers, if..elsif
if..else, if..then..else
if..elsif, and, or, and not
if..then, Comments
if..then..else, if..then..else
include, Included Modules, or “Mixins”
include?, loop, if..elsif
index, Hash Methods
information hiding, The One-Way-In, One-Way-Out Principle
inheritance, Class Hierarchies, Attributes, and Class Variables
initialize, Constructors: new and initialize
input and output. See IO (input and output), Constructors: new and initialize
inspect, Inspecting Objects
instance methods, Passing Arguments and Returning Values
instance variables, Instance Variables, Class Variables, Class Variables
instance_eval, Special Types of eval
instance_variables, Included Modules, or “Mixins”
instance_variable_get, Class Variables, Adding Variables and Methods
instance_variable_set, Adding Variables and Methods
integers, Assignment and Parameter Passing, Assignment and Parameter Passing, Parallel Assignment
object_id, Assignment and Parameter Passing
testing for equality, Parallel Assignment
integrated development environments (IDEs), Debugging and Testing, Ruby and Rails Development Software
Interactive Ruby (IRB), Debugging and Testing
invert, Hash Methods
IO (input and output), Strings, Numbers, Classes, and Objects, Getting and Putting Input, Getting and Putting Input, Format Strings, ensure: Execute Code Whether or Not an Error Occurs, Files and IO, Files and IO, Files and IO, Files and IO, Opening and Closing Files, Opening and Closing Files, Opening and Closing Files, A Discursion into Recursion, Marshal and Singletons
class, Files and IO
eof, Opening and Closing Files
exceptions in, ensure: Execute Code Whether or Not an Error Occurs
foreach, Files and IO
getc, Opening and Closing Files, Marshal and Singletons
gets, Getting and Putting Input
print, Getting and Putting Input
printf, Format Strings, A Discursion into Recursion
putc, Opening and Closing Files
puts, Strings, Numbers, Classes, and Objects
readlines, Files and IO
IRB (Interactive Ruby), Debugging and Testing
IronRuby, Ruby Implementations

J

JRuby, Ruby Implementations

K

Kernel, Modules as Namespaces, Including Modules from Files, Special Types of eval
key, Hash Methods
keys, Creating Hashes, Hash Methods

L

lambda, Block or Hash?
lambdas, Blocks and Arrays
< (less-than sign), Class Hierarchies, Attributes, and Class Variables, Comparing Values
indicating descent, Class Hierarchies, Attributes, and Class Variables
less-than sign (<), Class Hierarchies, Attributes, and Class Variables, Comparing Values
indicating descent, Class Hierarchies, Attributes, and Class Variables
LightTPD, A First Ruby on Rails Application, Web Servers
line breaks, IRB: Interactive Ruby, Unit Testing
(line continuation character), Unit Testing
line continuation character (), Unit Testing
Lisp, What Is Ruby?, Creating Objects from Blocks
load, Including Modules from Files
LoadError, Including Modules from Files
local variables. See variables, loop, Nameless Functions
LocalJumpError, Blocks as Iterators
loop, loop, Look Familiar?
loops, Class Variables, Class Variables, for Loops, while Loops, while Modifiers, while Modifiers, while Modifiers, Ensuring a while Loop Executes at Least Once, until Loops
begin..end, while Modifiers
each, for Loops
executing at least once, while Modifiers
for. See for loops, Class Variables, Ensuring a while Loop Executes at Least Once
until, Class Variables, until Loops
while, while Loops

M

Maglev, Ruby Implementations
main object, Messages, Methods, and Polymorphism
map, Mutexes
Marshal library, Marshal, Marshal, Saving and Loading Data, Saving and Loading Data, Saving and Loading Data, Saving and Loading Data, Saving and Loading Data, Omitting Variables on Saving, Omitting Variables on Saving, Omitting Variables on Saving, YAML and Singletons, Marshal and Singletons, Marshal and Singletons, Marshal and Singletons
and singletons, YAML and Singletons
compared to YAML, Saving and Loading Data
dump, Saving and Loading Data
file formats, Saving and Loading Data
load, Marshal, Omitting Variables on Saving
marshal_dump, Omitting Variables on Saving, Marshal and Singletons
marshal_load, Omitting Variables on Saving, Marshal and Singletons
omitting variables, Saving and Loading Data
TypeError, Saving and Loading Data
version numbers, Marshal and Singletons
MatchData, MatchData
Math, Modules as Namespaces, Including Modules from Files, Including Modules from Files
matrices, Hash Methods
Matsumoto, Yukihiro (Matz), Introduction
max, loop
messages, sending, Retrieving Data from an Object, Hash Methods
metaprogramming, Self-Modifying Programs
method, Symbols and Strings, Symbols and Variables
methods, Testing a Condition: if..then, Retrieving Data from an Object, Messages, Methods, and Polymorphism, Hash Methods, Methods, Class Methods, Class Methods, Class Variables, Class Variables, Ruby Constructors: new or initialize?, Ruby Constructors: new or initialize?, Ruby Constructors: new or initialize?, Singleton Classes, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Passing Arguments and Returning Values, Summarizing Instance, Class, and Singleton Methods, Summarizing Instance, Class, and Singleton Methods, Returning Values, Returning Multiple Values, Returning Multiple Values, Nameless Functions, Symbols and Variables, A Module Is Like a Class . . ., send, send, Removing Methods
adding at runtime, Symbols and Variables, send
and message sending, Hash Methods
class, Class Methods, Class Variables, Ruby Constructors: new or initialize?, Public, Protected, and Private Methods, Summarizing Instance, Class, and Singleton Methods
vs. instance methods, Class Variables
vs. singleton methods, Ruby Constructors: new or initialize?, Public, Protected, and Private Methods
declaring, Testing a Condition: if..then
default arguments, Returning Multiple Values
instance, Class Variables, Passing Arguments and Returning Values
vs. class methods, Class Variables
missing, Removing Methods
module, A Module Is Like a Class . . .
nameless, Nameless Functions
naming, and capitalization, Public, Protected, and Private Methods
nested, Public, Protected, and Private Methods
overriding, Singleton Classes
private, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods
in descendant classes, Public, Protected, and Private Methods
invading private methods, Public, Protected, and Private Methods
protected, Public, Protected, and Private Methods, Public, Protected, and Private Methods
public, Public, Protected, and Private Methods, Public, Protected, and Private Methods
removing at runtime, send
returning multiple values, Returning Multiple Values
returning values, Retrieving Data from an Object, Returning Values
singleton, Ruby Constructors: new or initialize?, Ruby Constructors: new or initialize?, Public, Protected, and Private Methods, Summarizing Instance, Class, and Singleton Methods
vs. class methods, Ruby Constructors: new or initialize?, Public, Protected, and Private Methods
static, Class Methods
method_defined?, Why Use Symbols?
method_missing, Handling Missing Methods
migration, Scaffolding
min, loop
mixins, Included Modules, or “Mixins”, Mix In with Care!, Mix In with Care!
potential problems with, Mix In with Care!
vs. multiple inheritance, Mix In with Care!
mkdir, Copying Files
Model, Test It!
Model-View-Controller (MVC), Do It Yourself . . ., Create a Controller, The Generate Controller Script Summarized, Test It!, Test It!, Test It!, Test It!
Controller, Create a Controller, Test It!
Model, Test It!
View, The Generate Controller Script Summarized, Test It!
modules, Modules and Mixins, A Module Is Like a Class . . ., A Module Is Like a Class . . ., A Module Is Like a Class . . ., Module Methods, Included Modules, or “Mixins”, Included Modules, or “Mixins”, Name Conflicts, Mix In with Care!, Mix In with Care!, Including Modules from Files, Including Modules from Files, Including Modules from Files, Including Modules from Files, Including Modules from Files
and class variables, Included Modules, or “Mixins”
and extend, Including Modules from Files
and functions, Including Modules from Files
and instance methods, A Module Is Like a Class . . .
and local variables, Included Modules, or “Mixins”
as namespaces, Module Methods
defined, Including Modules from Files
included. See mixins, Mix In with Care!
including from files, Mix In with Care!
predefined, Including Modules from Files
resolving name conflicts with, Name Conflicts
vs. classes, A Module Is Like a Class . . ., Including Modules from Files
module_eval, Special Types of eval
module_function, Including Modules from Files
Mongrel, A First Ruby on Rails Application, Web Servers
monkey patching. See dynamic programming, The Main Thread Priority
Mutex class, The Main Thread Priority
mv, Copying Files
MVC. See Model-View-Controller (MVC), Ruby on Rails, Creating a MySQL Database, Installing MySQL for Ruby on Rails, IDEs and Editors
MySQL, Do It Yourself . . ., Create a Rails Application, Creating a MySQL Database, Partials, Partials, Installing MySQL for Ruby on Rails, Downloading MySQL, Configuring MySQL, Configuring MySQL, Configuring MySQL, Configuring MySQL, Configuring MySQL, Can’t Find the Database?, Databases
.dll file (Windows), Can’t Find the Database?
configuring, Configuring MySQL
errors, Create a Rails Application, Partials, Partials, Configuring MySQL, Configuring MySQL
no such file to load, Create a Rails Application, Configuring MySQL
rake aborted, Partials
gem, installing, Configuring MySQL
installing, Downloading MySQL
username and password, Configuring MySQL

N

namespaces, Module Methods
nested methods, Public, Protected, and Private Methods
NetBeans, IDEs and Editors
new, Constructors: new and initialize
Nginx, Web Servers
nil, Arrays, Arrays, Creating Arrays, Making Matches
and array indexes, invalid, Arrays
displaying, Arrays, Making Matches
nil?, Creating Arrays
NilClass, Creating Arrays
not operator (!), if..then..else, and, or, and not, Alternative Case Syntax
!= (not-equals operator), and, or, and not
not-equals operator (!=), and, or, and not
numbers, Numbers

O

Object, Class Variables, Singleton Methods, Symbols and Strings, Symbols and Variables
methods, Symbols and Strings, Symbols and Variables
objects, Classes and Objects, Constructors: new and initialize, Parallel Assignment, Including Modules from Files, Including Modules from Files, Adding Variables and Methods, Exploring Further
creating at runtime, Adding Variables and Methods
extending, Including Modules from Files
freezing, Including Modules from Files, Exploring Further
identical, identifying, Parallel Assignment
inspecting, Constructors: new and initialize
ObjectSpace, Including Modules from Files
object_id, String Assignment, Assignment and Parameter Passing, Assignment and Parameter Passing
|| (or operator), if..then..else, Alternative Case Syntax
or operator (||), if..then..else, Alternative Case Syntax
overriding methods, Singleton Classes

P

p, Inspecting Objects
parallel assignments, Parallel Assignment
parameters. See arguments, Superclasses and Subclasses
parentheses, (), Getting and Putting Input, Superclasses and Subclasses, Superclasses and Subclasses, Attribute Readers and Writers, if..then..else, Parallel Assignment, Block or Hash?, File Operations
and super, Superclasses and Subclasses
avoiding ambiguity, if..then..else, Parallel Assignment, Block or Hash?
in regular expressions, File Operations
optional, Getting and Putting Input, Attribute Readers and Writers
partial classes, Class Variables
Pascal, Testing a Condition: if..then, for Loops
. (period), File Operations
period (.), File Operations
PI, Including Modules from Files
+ (plus sign), Making Matches, File Operations
plus sign (+), Making Matches, File Operations
polymorphism, Messages, Methods, and Polymorphism
PostgreSQL, Databases
Precision, Including Modules from Files
private methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods
in descendant classes, Public, Protected, and Private Methods
invading, Public, Protected, and Private Methods
Proc, Creating Objects from Blocks, Creating Objects from Blocks, Creating Objects from Blocks, Creating Objects from Blocks
in Ruby 1.8, Creating Objects from Blocks
in Ruby 1.9, Creating Objects from Blocks
new, Creating Objects from Blocks
Process, Including Modules from Files
procs, Blocks and Arrays
properties, Attribute Readers and Writers
protected methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods
public methods, Public, Protected, and Private Methods, Public, Protected, and Private Methods

Q

? (question mark), Prematch and Postmatch, File Operations
question mark (?), Prematch and Postmatch, File Operations

R

Rails, Ruby on Rails, Do It Yourself . . ., Create a Controller, Create a Controller, Create a Controller, Create a Controller, Create a Controller, Anatomy of a Simple Rails Application, Anatomy of a Simple Rails Application, Anatomy of a Simple Rails Application, Anatomy of a Simple Rails Application, Anatomy of a Simple Rails Application, The Generate Controller Script Summarized, The Generate Controller Script Summarized, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Create a View, Rails Tags, Rails Tags, Let’s Make a Blog!, Creating a MySQL Database, Creating a MySQL Database, Scaffolding, Scaffolding, Scaffolding, Partials, Test It!, Test It!, Test It!, Test It!, Test It!, Test It!
.rhtml, Rails Tags, Test It!
and ApplicationController, Anatomy of a Simple Rails Application
and class hierarchy, Create a View
and embedded Ruby, Create a View, Rails Tags
and HTML tags, Create a View, Create a View, Create a View
in Controller, Create a View
in strings, Create a View
and instance variables, Create a View
and MySQL, configuring, Creating a MySQL Database
and raw, Create a View
and render, Create a Controller, Anatomy of a Simple Rails Application, Create a View
blog application in, Let’s Make a Blog!
creating a View in, The Generate Controller Script Summarized
database.yml, Creating a MySQL Database
ERb files, Create a View, Test It!
folders, Test It!
generate, Create a Controller
generate controller, Create a Controller, Anatomy of a Simple Rails Application, The Generate Controller Script Summarized
generating view methods in, Anatomy of a Simple Rails Application
installating, Ruby on Rails
migration, Scaffolding
partials, Scaffolding
passing data from Controller to View, Create a View
pluralization, Test It!
routes, in Rails 3, Create a Controller
running server, Partials
scaffolding, Scaffolding
tags, Create a View, Create a View
templates, Test It!
updating, Do It Yourself . . .
vs. other frameworks, Test It!
“configuration by convention” approach, Create a Controller, Create a View
Rails 2, commands, Create a Rails Application, Create a Rails Application, Create a Rails Application, Create a Controller, The Generate Controller Script Summarized, Let’s Make a Blog!, Creating a MySQL Database, Partials
generate controller, Create a Rails Application, The Generate Controller Script Summarized
generate scaffold, Creating a MySQL Database
server, Create a Rails Application, Create a Controller, Partials
Rails 3, commands, Create a Rails Application, Create a Rails Application, Create a Rails Application, Create a Controller, The Generate Controller Script Summarized, Let’s Make a Blog!, Creating a MySQL Database, Partials
script/generate controller, Create a Rails Application, The Generate Controller Script Summarized
script/generate scaffold, Creating a MySQL Database
script/server, Create a Rails Application, Create a Controller, Partials
raise, raise: Reactivate a Handled Error
rake, Migration
Ramaze, Test It!
ranges, Format Strings
RDoc, Documenting Ruby with RDoc, Documenting Ruby with RDoc, Documenting Ruby with RDoc, Documenting Ruby with RDoc
adding title with, Documenting Ruby with RDoc
excluding comments from, Documenting Ruby with RDoc
formatting, Documenting Ruby with RDoc
readlines, Files and IO
receiver objects, Hash Methods, The One-Way-In, One-Way-Out Principle
modifying, The One-Way-In, One-Way-Out Principle
$/ (record separator), Removing Newline Characters: chop and chomp
record separator ($/), Removing Newline Characters: chop and chomp
recursions, Directory Inquiries, Sorting by Size
regular expressions (Regexp), Regular Expressions, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Match Groups, Match Groups, Match Groups, MatchData, MatchData, MatchData, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Greedy Matching, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations, File Operations
and strings, Prematch and Postmatch
captures, Match Groups, MatchData
custom delimiters, Making Matches
elements, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Making Matches, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, File Operations, File Operations, File Operations, File Operations
$, Making Matches, File Operations
$', Prematch and Postmatch
$`, Prematch and Postmatch
$˜, Prematch and Postmatch
%r, Making Matches
*, Making Matches, File Operations
+, Making Matches
// (delimiters), Making Matches
?, Prematch and Postmatch
^, Making Matches, File Operations
greedy, Greedy Matching
groups, Match Groups
match, Match Groups
MatchData, MatchData
matching, Making Matches
post_match, Prematch and Postmatch
pre_match, Prematch and Postmatch
processing paths, Prematch and Postmatch
quantifiers, Making Matches
quick reference, File Operations
samples of, File Operations
symbols, File Operations
to_a, MatchData
remove_method, Why Use Symbols?, Removing Methods
require, Including Modules from Files, Including Modules from Files, Including Modules from Files
problems, Including Modules from Files
vs. load, Including Modules from Files
require_relative, Including Modules from Files
rescue, Exception Handling
respond_to?, Singleton Methods
retry, retry: Attempt to Execute Code Again After an Error
return, Retrieving Data from an Object, Returning Values
RHTML, Rails Tags, Test It!
rm, Copying Files
Rubinius, Ruby Implementations
Ruby, Introduction, Introduction, Introduction, Making Sense of the Text, Getting the Source Code of the Sample Programs, Getting the Source Code of the Sample Programs, Debugging, Test It!, Further Reading, Books, Ebooks, Ebooks, Ruby and Rails Development Software, Ruby and Rails Development Software, Ruby and Rails Development Software, Databases, Databases
books on, Books
defined, Introduction
downloading, Making Sense of the Text, Databases
ebooks on, Ebooks
editors, Ruby and Rails Development Software
frameworks, Test It!
IDEs, Ruby and Rails Development Software
implementations, Introduction, Databases
library documentation, Getting the Source Code of the Sample Programs
one-click Installer, Debugging
running Ruby programs, Getting the Source Code of the Sample Programs
software, Ruby and Rails Development Software
style conventions, Introduction
websites on, Ebooks
Ruby 1.8, Introduction, The Ruby Library Documentation
Ruby 1.9, Class Variables, Class Variables, String Assignment, Arrays, Creating Arrays, Creating Arrays, Iterating over Arrays, Indexing into Arrays, Indexing into Arrays, Indexing into a Hash, Hash Methods, loop, loop, if..then..else, Case Statements, Alternative Case Syntax, Singleton Methods, Singleton Methods, Singleton Classes, retry: Attempt to Execute Code Again After an Error, Passing Named Proc Arguments, Blocks as Iterators, Blocks as Iterators, Why Use Symbols?, Included Modules, or “Mixins”, Including Modules from Files, Including Modules from Files, Opening and Closing Files, Marshal and Singletons, Marshal and Singletons, Making Matches, File Operations, Running Threads, The Main Thread, Thread Priorities, The Main Thread Priority, The Main Thread Priority, Mutexes, Fibers, Bindings, Bindings
BasicObject, Class Variables, Singleton Methods
binding, Bindings
block parameters, Passing Named Proc Arguments, Blocks as Iterators
class variable scope, Bindings
deadlocks, The Main Thread Priority
displaying arrays, Iterating over Arrays
fibers, Mutexes
getc, Marshal and Singletons
handling Ruby 1.8 compatibility, Opening and Closing Files
hash order, Indexing into a Hash, loop, loop
indexing a hash, Hash Methods
instance_variables, Included Modules, or “Mixins”
local variables, Blocks as Iterators
Marshal version numbers, Marshal and Singletons
nil, Arrays, Making Matches
not, Alternative Case Syntax
print, Creating Arrays, Indexing into Arrays
puts, Creating Arrays, Indexing into Arrays
regular expressions, symbols, File Operations
require, Including Modules from Files
require_relative, Including Modules from Files
singleton_methods, Singleton Classes
sorting symbols, Why Use Symbols?
string indexing, String Assignment
then syntax, unsupported, if..then..else, Case Statements
Thread.pass, Fibers
threads, Running Threads, The Main Thread, Thread Priorities, The Main Thread Priority
priorities, Thread Priorities, The Main Thread Priority
statuses, The Main Thread
to_s, with exceptions, retry: Attempt to Execute Code Again After an Error
Ruby 2.0, Introduction
Ruby Gems, Do It Yourself . . .
Ruby In Steel, Sorting by Size, Unit Testing, IDEs and Editors
Ruby on Rails. See Rails, Debugging
rubygems.rb, Debugging
RubyMine, IDEs and Editors
RUBYOPT, Debugging
RUBY_VERSION, Characters and Compatibility

S

saving data. See Marshal library; YAML, Creating a MySQL Database
scaffolding, Scaffolding
:: (scope resolution operator), Class Variables, Symbols and Strings, Module Methods, Including Modules from Files, Special Types of eval
scope resolution operator (::), Class Variables, Symbols and Strings, Module Methods, Including Modules from Files, Special Types of eval
scopes, Local and Global Variables
send, Public, Protected, and Private Methods, Adding Variables and Methods, send
serialization, Omitting Variables on Saving
server ports, Create a Rails Application
sets, Hash Methods, Hash Methods, Hash Methods, Hash Methods, Hash Methods
adding new values to, Hash Methods
merging, Hash Methods
sorting, Hash Methods
testing for equality, Hash Methods
setup. See unit testing, Including Modules from Files
Signal, Including Modules from Files
Sinatra, Test It!
singleton class methods, Public, Protected, and Private Methods
singleton classes, Singleton Methods
singleton methods, Ruby Constructors: new or initialize?, Summarizing Instance, Class, and Singleton Methods
singletons, Omitting Variables on Saving, Omitting Variables on Saving, YAML and Singletons, YAML and Singletons
and Marshal library, YAML and Singletons
and YAML, Omitting Variables on Saving
saving, and reloading, Omitting Variables on Saving
singleton_methods, Singleton Methods, Singleton Classes
sleep, Running Threads
Smalltalk, What Is Ruby?, Classes and Objects, Messages, Methods, and Polymorphism, The One-Way-In, One-Way-Out Principle
sort, Hash Order, loop, Sorting by Size
source code for this book, Getting the Source Code of the Sample Programs
SQL Server Express, Databases
SQLite, Installing Rails, Do It Yourself . . ., Create a Rails Application, Databases
and Rails, Installing Rails
no such file to load, Create a Rails Application
SQLite3, installaing, Do It Yourself . . .
sqrt, Including Modules from Files
[] (square brackets), File Operations
square brackets, [], File Operations
static methods. See class methods, Iterating with a Range
static variables. See class variables, Iterating with a Range
string literals, Iterating with a Range
strings. See also regular expressions, Getting and Putting Input, Getting and Putting Input, Strings and Embedded Evaluation, Inspecting Objects, Strings and Ranges, Strings and Ranges, Strings and Ranges, Strings and Ranges, Backquotes, Concatenation, Concatenation, What About Commas?, String Assignment, String Assignment, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Indexing into a String, Removing Newline Characters: chop and chomp, Removing Newline Characters: chop and chomp, Removing Newline Characters: chop and chomp, Format Strings, Creating Arrays, The One-Way-In, One-Way-Out Principle, Blocks and Arrays, Blocks and Arrays, Blocks and Arrays, Blocks and Arrays, Blocks and Arrays, Opening and Closing Files, Opening and Closing Files, A Discursion into Recursion, Marshal and Singletons, Making Matches, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Prematch and Postmatch, Greedy Matching, String Methods, String Methods, String Methods, String Methods
=˜, Prematch and Postmatch
and capitalize method, String Assignment, Indexing into a String, Blocks and Arrays
and capitalize! method, Blocks and Arrays
and chomp method, Removing Newline Characters: chop and chomp
and chop method, Removing Newline Characters: chop and chomp
and embedded evaluation, Getting and Putting Input, Strings and Ranges
and insert method, Indexing into a String
and ord method, Opening and Closing Files, Marshal and Singletons
and reverse method, Indexing into a String
and reverse! method, The One-Way-In, One-Way-Out Principle
and to_f method, Strings and Embedded Evaluation, Opening and Closing Files
and to_s method, Inspecting Objects
assignments, What About Commas?
backquotes, Backquotes, Creating Arrays
character codes, Concatenation
chr, Blocks and Arrays
concatenation, Concatenation
delimiters, user-defined, Strings and Ranges
double-quoted, Getting and Putting Input, Strings and Ranges
downcase, Indexing into a String
each_byte, Blocks and Arrays
format, Format Strings
formatting, A Discursion into Recursion
gsub, String Methods
indexing into, String Assignment
length, Indexing into a String
matching, Making Matches, Prematch and Postmatch, Greedy Matching
methods of String class, Prematch and Postmatch
regular expressions, Making Matches
record separator ($/), Removing Newline Characters: chop and chomp
scan, Prematch and Postmatch
single-quoted, Strings and Ranges
slice, String Methods
split, Indexing into a String, Blocks and Arrays, String Methods
squeeze, Indexing into a String
sub, String Methods
swapcase, Indexing into a String
upcase, Indexing into a String
super, Superclasses and Subclasses, Calling Methods of a Superclass, Class Variables, Class Variables
superclasses, Class Hierarchies, Attributes, and Class Variables, Class Variables
symbols, Attribute Readers and Writers, Symbols, Symbols, Symbols, Symbols, Symbols and Strings, Symbols and Variables, Symbols and Variables, Symbols and Variables, Symbols and Variables, Why Use Symbols?, Why Use Symbols?, File Operations
and dynamic programming, Symbols and Variables
and regular expressions, File Operations
and variables, Symbols and Variables
defined, Symbols, Why Use Symbols?
evaluating, Symbols and Variables
scope of, Symbols and Strings
sorting, Why Use Symbols?
uniqueness of, Symbols
usefulness of, Symbols and Variables
vs. strings, Symbols

T

teardown, Unit Testing
TestCase, Unit Testing
TextMate, IDEs and Editors
then, Comments
threads, Threads, Creating Threads, Running Threads, Running Threads, Going Native, Going Native, Going Native, The Main Thread, The Main Thread, Thread Status, Thread Status, Thread Status, Ensuring That a Thread Executes, Thread Priorities, Thread Priorities, Thread Priorities, Thread Priorities, The Main Thread Priority, The Main Thread Priority, The Main Thread Priority, Mutexes, Fibers, Fibers, Fibers, Fibers
and fibers, Fibers
and join method, Thread Status
and pass method, Ensuring That a Thread Executes, Fibers
and preemptive multitasking, Running Threads
and sleep method, Thread Status
and stop method, The Main Thread Priority, Fibers
creating, Creating Threads
deadlocks, The Main Thread Priority
ensuring execution of, Thread Status
green, Going Native
main, The Main Thread, Thread Priorities
mutexes, The Main Thread Priority
native, Going Native
priorities, Thread Priorities, Thread Priorities, Thread Priorities
problems, Thread Priorities
setting, Thread Priorities
running, Running Threads
scheduling, Fibers
statuses, The Main Thread
synchronizing, Mutexes
time-slicing, Going Native
throw, Alternative Case Syntax, raise: Reactivate a Handled Error
times, What Is a Block?, Blocks as Iterators
to_a, Ranges, MatchData
to_f, Strings and Embedded Evaluation, Opening and Closing Files
to_s, Inspecting Objects, Attribute Readers and Writers, retry: Attempt to Execute Code Again After an Error
to_yaml, Converting to YAML

U

ubygems.rb, Debugging
undef_method, Removing Methods
unit testing, Unit Testing, Unit Testing, Unit Testing, Unit Testing, Unit Testing
assertions available, Unit Testing
setup, Unit Testing
teardown, Unit Testing
TestCase, Unit Testing
unless modifiers, if..elsif
unless tests, if..elsif
until loops, Ensuring a while Loop Executes at Least Once
upto, Iterating upto and downto

V

variables, Testing a Condition: if..then, Local and Global Variables, Instance Variables, Attribute Readers and Writers, Attribute Readers and Writers, What Are Class Methods For?, Class Variables, Class Variables, Class Variables, Symbols and Strings, Included Modules, or “Mixins”
class, Attribute Readers and Writers
class instance, Class Variables
class methods, Class Variables
global, Testing a Condition: if..then, Symbols and Strings
in modules, Included Modules, or “Mixins”
instance, Instance Variables, Class Variables
local, Local and Global Variables
static, What Are Class Methods For?
vectors, Hash Methods
| (vertical pipe), File Operations
vertical pipe (|), File Operations
View, The Generate Controller Script Summarized, Test It!

W

Waves, Test It!
web servers, A First Ruby on Rails Application, Web Servers
WEBrick, A First Ruby on Rails Application, Create a Rails Application, IDEs and Editors
running, Create a Rails Application
website, IDEs and Editors
websites, on Ruby, Ebooks
when, if and unless Modifiers, The === Method
while loops, Multiple Iterator Arguments
while modifiers, Multiple Iterator Arguments, if and unless Modifiers
word counter, String Methods

Y

y, Converting to YAML
YAML, YAML, Converting to YAML, Converting to YAML, Converting to YAML, Converting to YAML, Converting to YAML, Nested Sequences, Nested Sequences, Nested Sequences, Nested Sequences, Nested Sequences, Saving YAML Data, Omitting Variables on Saving, Multiple Documents, One File, Multiple Documents, One File, Multiple Documents, One File, Multiple Documents, One File, A YAML Database, Adventures in YAML, Adventures in YAML, Adventures in YAML, Adventures in YAML, Adventures in YAML, Omitting Variables on Saving
adventure game, Adventures in YAML
and dump method, Nested Sequences
and hashes, Adventures in YAML
and indentation, Nested Sequences, Adventures in YAML
and load_documents method, Multiple Documents, One File
and nested sequences, Nested Sequences
and singletons, Omitting Variables on Saving
arrays, Converting to YAML, Adventures in YAML
documents, Converting to YAML, Multiple Documents, One File
elements, Converting to YAML
formats, Adventures in YAML
loading data, Nested Sequences, Multiple Documents, One File
omitting variables, Saving YAML Data
reconstructing complex data, A YAML Database
saving data, Nested Sequences, Multiple Documents, One File
to_yaml, Converting to YAML
to_yaml_properties, Omitting Variables on Saving
y, Converting to YAML
YARV (Yet Another Ruby Virtual-machine), Going Native
yield, loop, yield
..................Content has been hidden....................

You can't read the all page of ebook, please click here login for view all page.
Reset
18.191.235.176