Programming Ruby: The Pragmatic Programmer's Guide, Second Edition / Edition 2

by Dave Thomas, Chad Fowler, Andy Hunt

Overview

Ruby is an increasingly popular, fully object-oriented dynamic programming language, hailed by many practitioners as the finest and most useful language available today. When Ruby first burst onto the scene in the Western world, the Pragmatic Programmers were there with the definitive reference manual, Programming Ruby: The Pragmatic Programmer's Guide.

Now in its second edition, author Dave Thomas has expanded the famous Pickaxe book with over 200 pages of new content, covering all the improved language features of Ruby 1.8 and standard library modules. The Pickaxe contains four major sections:

• An acclaimed tutorial on using Ruby.
• The definitive reference to the language.
• Complete documentation on all built-in classes, modules, and methods
• Complete descriptions of all 98 standard libraries.

If you enjoyed the First Edition, you'll appreciate the expanded content, including enhanced coverage of installation, packaging, documenting Ruby source code, threading and synchronization, and enhancing Ruby's capabilities using C-language extensions. Programming for the World Wide Web is easy in Ruby, with new chapters on XML/RPC, SOAP, distributed Ruby, templating systems, and other web services. There's even a new chapter on unit testing.

This is the definitive reference manual for Ruby, including a description of all the standard library modules, a complete reference to all built-in classes and modules (including more than 250 significant changes since the First Edition). Coverage of other features has grown tremendously, including details on how to harness the sophisticated capabilities of irb, so you can dynamically examine and experiment with your running code. "Ruby is a wonderfully powerful and useful language, and whenever I'm working with it this book is at my side" —Martin Fowler, Chief Scientist, ThoughtWorks

Product Details

ISBN-13:	9780974514055
Publisher:	Pragmatic Bookshelf
Publication date:	10/28/2004
Series:	Pragmatic Programmers Series
Edition description:	Second Edition
Pages:	864
Product dimensions:	7.38(w) x 9.25(h) x 1.56(d)

About the Author

Dave Thomas, as one of the authors of the Agile Manifesto, understands agility. As the author of "Programming Ruby," he understands Ruby. And, as an active Rails developer, he knows Rails.

Chad Fowler is co-director of Ruby Central, Inc., and remains an active, driving force in the Ruby community.

Andy Hunt is a programmer turned consultant, author and publisher. He co-authored the best-selling book “The Pragmatic Programmer”, was one of the 17 founders of the Agile Alliance, and co-founded the Pragmatic Bookshelf, publishing award-winning and critically acclaimed books for software developers.

Table of Contents

	Foreword to the First Edition	xxi
	Foreword to the Second Edition	xxiii
	Preface	xxv
	Road Map	xxxi
Part I	Facets of Ruby
1	Getting Started	3
	Installing Ruby	3
	Running Ruby	5
	Ruby Documentation: RDoc and ri	8
2	Ruby.new	11
	Ruby Is an Object-Oriented Language	11
	Some Basic Ruby	13
	Arrays and Hashes	16
	Control Structures	18
	Regular Expressions	19
	Blocks and Iterators	21
	Reading and 'Riting	23
	Onward and Upward	24
3	Classes, Objects, and Variables	25
	Inheritance and Messages	27
	Objects and Attributes	29
	Class Variables and Class Methods	33
	Access Control	37
	Variables	39
4	Containers, Blocks, and Iterators	43
	Containers	43
	Blocks and Iterators	49
	Containers Everywhere	57
5	Standard Types	59
	Numbers	59
	Strings	61
	Ranges	66
	Regular Expressions	68
6	More about Methods	79
	Defining a Method	79
	Calling a Method	81
7	Expressions	87
	Operator Expressions	88
	Miscellaneous Expressions	89
	Assignment	90
	Conditional Execution	93
	Case Expressions	98
	Loops	100
	Variable Scope, Loops, and Blocks	105
8	Exceptions, Catch, and Throw	107
	The Exception Class	107
	Handling Exceptions	108
	Raising Exceptions	112
	Catch and Throw	114
9	Modules	117
	Namespaces	117
	Mixins	118
	Iterators and the Enumerable Module	120
	Composing Modules	120
	Including Other Files	123
10	Basic Input and Output	127
	What Is an IO Object?	127
	Opening and Closing Files	128
	Reading and Writing Files	129
	Talking to Networks	133
11	Threads and Processes	135
	Multithreading	135
	Controlling the Thread Scheduler	140
	Mutual Exclusion	141
	Running Multiple Processes	147
12	Unit Testing	151
	Test::Unit Framework	152
	Structuring Tests	156
	Organizing and Running Tests	159
13	When Trouble Strikes	163
	Ruby Debugger	163
	Interactive Ruby	164
	Editor Support	165
	But It Doesn't Work!	167
	But It's Too Slow!	170
Part II	Ruby in Its Setting
14	Ruby and Its World	177
	Command-Line Arguments	177
	Program Termination	180
	Environment Variables	181
	Where Ruby Finds Its Modules	182
	Build Environment	183
15	Interactive Ruby Shell	185
	Command Line	185
	Configuration	190
	Commands	194
	Restrictions	196
	Rtags and xmp	196
16	Documenting Ruby	199
	Adding RDoc to Ruby Code	199
	Adding RDoc to C Extensions	207
	Running RDoc	211
	Displaying Program Usage	212
17	Package Management with RubyGems	215
	Installing RubyGems	216
	Installing Application Gems	216
	Installing and Using Gem Libraries	218
	Creating Your Own Gems	223
18	Ruby and the Web	235
	Writing CGI Scripts	235
	Cookies	244
	Improving Performance	247
	Choice of Web Servers	247
	SOAP and Web Services	249
	More Information	253
19	Ruby TK	255
	Simple TK Application	255
	Widgets	256
	Binding Events	260
	Canvas	261
	Scrolling	263
	Translating from Perl/TK Documentation	265
20	Ruby and Microsoft Windows	267
	Getting Ruby for Windows	267
	Running Ruby Under Windows	268
	Win32API	268
	Windows Automation	269
21	Extending Ruby	275
	Your First Extension	275
	Ruby Objects in C	278
	The Jukebox Extension	284
	Memory Allocation	293
	Ruby Type System	294
	Creating an Extension	296
	Embedding a Ruby Interpreter	301
	Bridging Ruby to Other Languages	304
	Ruby C Language API	305
Part III	Ruby Crystallized
22	The Ruby Language	317
	Source Layout	317
	The Basic Types	319
	Names	328
	Variables and Constants	330
	Expressions	338
	Method Definition	345
	Invoking a Method	348
	Aliasing	351
	Class Definition	352
	Module Definitions	354
	Access Control	356
	Blocks, Closures, and Proc Objects	356
	Exceptions	360
	Catch and Throw	362
23	Duck Typing	365
	Classes Aren't Types	366
	Coding like a Duck	370
	Standard Protocols and Coercions	371
	Walk the Walk, Talk the Talk	377
24	Classes and Objects	379
	How Classes and Objects Interact	379
	Class and Module Definitions	387
	Top-Level Execution Environment	393
	Inheritance and Visibility	393
	Freezing Objects	394
25	Locking Ruby in the Safe	397
	Safe Levels	398
	Tainted Objects	399
26	Reflection, ObjectSpace, and Distributed Ruby	403
	Looking at Objects	404
	Looking at Classes	405
	Calling Methods Dynamically	407
	System Hooks	410
	Tracing Your Program's Execution	412
	Marshaling and Distributed Ruby	414
	Compile Time? Runtime? Anytime!	419
Part IV	Ruby Library Reference
27	Built-in Classes and Modules	423
	Alphabetical Listing	424
28	Standard Library	653
Part V	Appendixes
A	Socket Library	763
B	Mkmf Reference	779
C	Support	783
	Web Sites	783
	Download Sites	784
	Usenet Newsgroup	784
	Mailing Lists	784
D	Bibliography	787
	Index	789
	Summary Tables	824