Ruby Programming
	Home	Next Page

Ruby Programming

Table of Contents

Foreword

Preface

Ruby Sparkles

What Kind of Language Is Ruby?

Is Ruby for Me?

Why Did We Write This Book?

Ruby Versions

Installing Ruby

Building Ruby

Running Ruby

Interactive Ruby

Ruby Programs

Resources

Acknowledgments

Notation Conventions

Roadmap

Ruby.new

Ruby Is an Object-Oriented Language

Some Basic Ruby

Arrays and Hashes

Control Structures

Regular Expressions

Blocks and Iterators

Reading and 'Riting

Onward and Upward

Classes, Objects, and Variables

Inheritance and Messages

Inheritance and Mixins

Objects and Attributes

Writable Attributes

Virtual Attributes

Class Variables and Class Methods

Class Variables

Class Methods

Singletons and Other Constructors

Access Control

Specifying Access Control

Variables

Containers, Blocks, and Iterators

Containers

Arrays

Hashes

Implementing a SongList Container

Blocks and Iterators

Implementing Iterators

Ruby Compared with C++ and Java

Blocks for Transactions

Blocks Can Be Closures

Standard Types

Numbers

Strings

Working with Strings

Ranges

Ranges as Sequences

Ranges as Conditions

Ranges as Intervals

Regular Expressions

Patterns

Anchors

Character Classes

Repetition

Alternation

Grouping

Pattern-Based Substitution

Backslash Sequences in the Substitution

Object-Oriented Regular Expressions

More About Methods

Defining a Method

Variable-Length Argument Lists

Methods and Blocks

Calling a Method

Expanding Arrays in Method Calls

Making Blocks More Dynamic

Collecting Hash Arguments

Expressions

Operator Expressions

Miscellaneous Expressions

Command Expansion

Backquotes Are Soft

Assignment

Parallel Assignment

Nested Assignments

Other Forms of Assignment

Conditional Execution

Boolean Expressions

Defined?, And, Or, and Not

If and Unless Expressions

If and Unless Modifiers

Case Expressions

Loops

Iterators

For ... In

Break, Redo, and Next

Retry

Variable Scope and Loops

Exceptions, Catch, and Throw

The Exception Class

Handling Exceptions

Tidying Up

Play It Again

Raising Exceptions

Adding Information to Exceptions

Catch and Throw

Modules

Namespaces

Mixins

Instance Variables in Mixins

Iterators and the Enumerable Module

Including Other Files

Basic Input and Output

What Is an IO Object?

Opening and Closing Files

Reading and Writing Files

Iterators for Reading

Writing to Files

But I Miss My C++ Iostream

Talking to Networks

Threads and Processes

Multithreading

Creating Ruby Threads

Manipulating Threads

Thread Variables

Threads and Exceptions

Controlling the Thread Scheduler

Mutual Exclusion

The Mutex Class

Condition Variables

Running Multiple Processes

Spawning New Processes

Independent Children

Blocks and Subprocesses

When Trouble Strikes

Ruby Debugger

Interactive Ruby

Editor Support

But It Doesn't Work!

But It's Too Slow!

Create Locals Outside Blocks

Use the Profiler

Ruby and Its World

Command-Line Arguments

Command-Line Options

ARGV

Program Termination

Environment Variables

Writing to Environment Variables

Where Ruby Finds Its Modules

Build Environment

Ruby and the Web

Writing CGI Scripts

Using cgi.rb

Quoting

Forms

Creating Forms and HTML

Cookies

Sessions

Embedding Ruby in HTML

Using eruby

Installing eruby in Apache

Improving Performance

Ruby Tk

Simple Tk Application

Widgets

Setting Widget Options

Getting Widget Data

Setting/Getting Options Dynamically

Sample Application

Binding Events

Canvas

Scrolling

Just One More Thing

Translating from Perl/Tk Documentation

Object Creation

Options

Variable References

Ruby and Microsoft Windows

Ruby Ports

Running Ruby Under Windows

Win32API

Windows Automation

Getting and Setting Properties

Named Arguments

for each

An Example

Optimizing

Extending Ruby

Ruby Objects in C

VALUE as a Pointer

VALUE as an Immediate Object

Writing Ruby in C

Evaluating Ruby Expressions in C

Sharing Data Between Ruby and C

Directly Sharing Variables

Wrapping C Structures

An Example

Memory Allocation

Creating an Extension

Creating a Makefile with extconf.rb

Static Linking

Embedding a Ruby Interpreter

Bridging Ruby to Other Languages

Ruby C Language API

The Ruby Language

Source Layout

BEGIN and END Blocks

General Delimited Input

The Basic Types

Integer and Floating Point Numbers

Strings

Ranges

Arrays

Hashes

Requirements for a Hash Key

Symbols

Regular Expressions

Regular Expression Options

Regular Expression Patterns

Substitutions

Extensions

Names

Variable/Method Ambiguity

Variables and Constants

Scope of Constants and Variables

Classes and Objects

How Classes and Objects Interact

Your Basic, Everyday Object

Object-Specific Classes

Mixin Modules

Extending Objects

Class and Module Definitions

Class Names Are Constants

Top-Level Execution Environment

Inheritance and Visibility

Freezing Objects

Locking Ruby in the Safe

Safe Levels

Tainted Objects

Reflection, ObjectSpace, and Distributed Ruby

Looking at Objects

Looking Inside Objects

Looking at Classes

Looking Inside Classes

Calling Methods Dynamically

Performance Considerations

System Hooks

Runtime Callbacks

Tracing Your Program's Execution

How Did We Get Here?

Marshaling and Distributed Ruby

Custom Serialization Strategy

Distributed Ruby

Compile Time? Runtime? Anytime!

Built-in Classes and Methods

Standard Library

Object-Oriented Design Libraries

The Visitor Pattern

Network and Web Libraries

Socket-Level Access

Higher-Level Access

CGI Development

HTML Output Methods

Multipart Form Values

Microsoft Windows Support

Embedded Documentation

Inline Formatting

Cross References

Method Names

Including Other Files

Using rdtool

Mandatory Disclaimer

Interactive Ruby Shell

Command Line

Initialization File

Commands

Configuring the Prompt

Restrictions

rtags, xmp, and the Frame Class

rtags

xmp

The Frame Class

Support

Web Sites

Download Sites

Usenet Newsgroup

Mailing Lists

Bug Reporting

Ruby Programming
	Home	Next Page