Table of Contents


book cover
The Ruby Way: Solutions and Techniques in Ruby Programming, Second Edition
By Hal Fulton
...............................................
Publisher: Addison Wesley Professional
Pub Date: October 25, 2006
Print ISBN-10: 0-672-32884-4
Print ISBN-13: 978-0-672-32884-8
Pages: 888
 

Table of Contents  | Index

   Copyright
    
   Foreword
   Acknowledgments
   About the Author
   Introduction
        Chapter 1.  Ruby in Review
      Section 1.1.  An Introduction to Object Orientation
      Section 1.2.  Basic Ruby Syntax and Semantics
      Section 1.3.  OOP in Ruby
      Section 1.4.  Dynamic Aspects of Ruby
      Section 1.5.  Training Your Intuition: Things to Remember
      Section 1.6.  Ruby Jargon and Slang
      Section 1.7.  Conclusion
        Chapter 2.  Working with Strings
      Section 2.1.  Representing Ordinary Strings
      Section 2.2.  Representing Strings with Alternate Notations
      Section 2.3.  Using Here-Documents
      Section 2.4.  Finding the Length of a String
      Section 2.5.  Processing a Line at a Time
      Section 2.6.  Processing a Byte at a Time
      Section 2.7.  Performing Specialized String Comparisons
      Section 2.8.  Tokenizing a String
      Section 2.9.  Formatting a String
      Section 2.10.  Using Strings As IO Objects
      Section 2.11.  Controlling Uppercase and Lowercase
      Section 2.12.  Accessing and Assigning Substrings
      Section 2.13.  Substituting in Strings
      Section 2.14.  Searching a String
      Section 2.15.  Converting Between Characters and ASCII Codes
      Section 2.16.  Implicit and Explicit Conversion
      Section 2.17.  Appending an Item Onto a String
      Section 2.18.  Removing Trailing Newlines and Other Characters
      Section 2.19.  Trimming Whitespace from a String
      Section 2.20.  Repeating Strings
      Section 2.21.  Embedding Expressions Within Strings
      Section 2.22.  Delayed Interpolation of Strings
      Section 2.23.  Parsing Comma-Separated Data
      Section 2.24.  Converting Strings to Numbers (Decimal and Otherwise)
      Section 2.25.  Encoding and Decoding rot13 Text
      Section 2.26.  Encrypting Strings
      Section 2.27.  Compressing Strings
      Section 2.28.  Counting Characters in Strings
      Section 2.29.  Reversing a String
      Section 2.30.  Removing Duplicate Characters
      Section 2.31.  Removing Specific Characters
      Section 2.32.  Printing Special Characters
      Section 2.33.  Generating Successive Strings
      Section 2.34.  Calculating a 32-Bit CRC
      Section 2.35.  Calculating the MD5 Hash of a String
      Section 2.36.  Calculating the Levenshtein Distance Between Two Strings
      Section 2.37.  Encoding and Decoding base64 Strings
      Section 2.38.  Encoding and Decoding Strings (uuencode/uudecode)
      Section 2.39.  Expanding and Compressing Tab Characters
      Section 2.40.  Wrapping Lines of Text
      Section 2.41.  Conclusion
        Chapter 3.  Working with Regular Expressions
      Section 3.1.  Regular Expression Syntax
      Section 3.2.  Compiling Regular Expressions
      Section 3.3.  Escaping Special Characters
      Section 3.4.  Using Anchors
      Section 3.5.  Using Quantifiers
      Section 3.6.  Positive and Negative Lookahead
      Section 3.7.  Accessing Backreferences
      Section 3.8.  Using Character Classes
      Section 3.9.  Extended Regular Expressions
      Section 3.10.  Matching a Newline with a Dot
      Section 3.11.  Using Embedded Options
      Section 3.12.  Using Embedded Subexpressions
      Section 3.13.  Ruby and Oniguruma
      Section 3.14.  A Few Sample Regular Expressions
      Section 3.15.  Conclusion
        Chapter 4.  Internationalization in Ruby
      Section 4.1.  Background and Terminology
      Section 4.2.  Coding in a Post-ASCII World
      Section 4.3.  Using Message Catalogs
      Section 4.4.  Conclusion
        Chapter 5.  Performing Numerical Calculations
      Section 5.1.  Representing Numbers in Ruby
      Section 5.2.  Basic Operations on Numbers
      Section 5.3.  Rounding Floating Point Values
      Section 5.4.  Comparing Floating Point Numbers
      Section 5.5.  Formatting Numbers for Output
      Section 5.6.  Formatting Numbers with Commas
      Section 5.7.  Working with Very Large Integers
      Section 5.8.  Using BigDecimal
      Section 5.9.  Working with Rational Values
      Section 5.10.  Matrix Manipulation
      Section 5.11.  Working with Complex Numbers
      Section 5.12.  Using mathn
      Section 5.13.  Finding Prime Factorization, GCD, and LCM
      Section 5.14.  Working with Prime Numbers
      Section 5.15.  Implicit and Explicit Numeric Conversion
      Section 5.16.  Coercing Numeric Values
      Section 5.17.  Performing Bit-level Operations on Numbers
      Section 5.18.  Performing Base Conversions
      Section 5.19.  Finding Cube Roots, Fourth Roots, and so on
      Section 5.20.  Determining the Architecture's Byte Order
      Section 5.21.  Numerical Computation of a Definite Integral
      Section 5.22.  Trigonometry in Degrees, Radians, and Grads
      Section 5.23.  More Advanced Trigonometry
      Section 5.24.  Finding Logarithms with Arbitrary Bases
      Section 5.25.  Finding the Mean, Median, and Mode of a Data Set
      Section 5.26.  Variance and Standard Deviation
      Section 5.27.  Finding a Correlation Coefficient
      Section 5.28.  Generating Random Numbers
      Section 5.29.  Caching Functions with memoize
      Section 5.30.  Conclusion
        Chapter 6.  Symbols and Ranges
      Section 6.1.  Symbols
      Section 6.2.  Ranges
      Section 6.3.  Conclusion
        Chapter 7.  Working with Times and Dates
      Section 7.1.  Determining the Current Time
      Section 7.2.  Working with Specific Times (Post-epoch)
      Section 7.3.  Determining the Day of the Week
      Section 7.4.  Determining the Date of Easter
      Section 7.5.  Finding the Nth Weekday in a Month
      Section 7.6.  Converting Between Seconds and Larger Units
      Section 7.7.  Converting To and From the Epoch
      Section 7.8.  Working with Leap Seconds: Don't!
      Section 7.9.  Finding the Day of the Year
      Section 7.10.  Validating a Date/Time
      Section 7.11.  Finding the Week of the Year
      Section 7.12.  Detecting Leap Years
      Section 7.13.  Obtaining the Time Zone
      Section 7.14.  Working with Hours and Minutes Only
      Section 7.15.  Comparing Date/Time Values
      Section 7.16.  Adding Intervals to Date/Time Values
      Section 7.17.  Computing the Difference in Two Date/Time Values
      Section 7.18.  Working with Specific Dates (Pre-epoch)
      Section 7.19.  Interconverting Between Time, Date, and DateTime
      Section 7.20.  Retrieving a Date/Time Value from a String
      Section 7.21.  Formatting and Printing Date/Time Values
      Section 7.22.  Time Zone Conversions
      Section 7.23.  Determining the Number of Days in a Month
      Section 7.24.  Dividing a Month into Weeks
      Section 7.25.  Conclusion
        Chapter 8.  Arrays, Hashes, and Other Enumerables
      Section 8.1.  Working with Arrays
      Section 8.2.  Working with Hashes
      Section 8.3.  Enumerables in General
      Section 8.4.  Conclusion
        Chapter 9.  More Advanced Data Structures
      Section 9.1.  Working with Sets
      Section 9.2.  Working with Stacks and Queues
      Section 9.3.  Working with Trees
      Section 9.4.  Working with Graphs
      Section 9.5.  Conclusion
        Chapter 10.  I/O and Data Storage
      Section 10.1.  Working with Files and Directories
      Section 10.2.  Performing Higher-Level Data Access
      Section 10.3.  Using KirbyBase
      Section 10.4.  Connecting to External Databases
      Section 10.5.  Conclusion
        Chapter 11.  OOP and Dynamic Features in Ruby
      Section 11.1.  Everyday OOP Tasks
      Section 11.2.  More Advanced Techniques
      Section 11.3.  Working with Dynamic Features
      Section 11.4.  Conclusion
        Chapter 12.  Graphical Interfaces for Ruby
      Section 12.1.  Ruby/Tk
      Section 12.2.  Ruby/GTK2
      Section 12.3.  FXRuby (FOX)
      Section 12.4.  QtRuby
      Section 12.5.  Other GUI Toolkits
      Section 12.6.  Conclusion
        Chapter 13.  Threads in Ruby
      Section 13.1.  Creating and Manipulating Threads
      Section 13.2.  Synchronizing Threads
      Section 13.3.  Conclusion
        Chapter 14.  Scripting and System Administration
      Section 14.1.  Running External Programs
      Section 14.2.  Command-Line Options and Arguments
      Section 14.3.  The Shell Library
      Section 14.4.  Accessing Environment Variables
      Section 14.5.  Scripting in Microsoft Windows
      Section 14.6.  The Windows One-Click Installer
      Section 14.7.  Libraries You Need to Know About
      Section 14.8.  Working with Files, Directories, and Trees
      Section 14.9.  Miscellaneous Scripting Tasks
      Section 14.10.  Conclusion
        Chapter 15.  Ruby and Data Formats
      Section 15.1.  Parsing XML with REXML
      Section 15.2.  Working with RSS and Atom
      Section 15.3.  Manipulating Image Data with RMagick
      Section 15.4.  Creating PDF Documents with PDF::Writer
      Section 15.5.  Conclusion
        Chapter 16.  Testing and Debugging
      Section 16.1.  Testing with Test::Unit
      Section 16.2.  The ZenTest Tools
      Section 16.3.  Using the Ruby Debugger
      Section 16.4.  Using irb As a Debugger
      Section 16.5.  Measuring Code Coverage
      Section 16.6.  Measuring Performance
      Section 16.7.  Prettyprinting Objects
      Section 16.8.  Conclusion
        Chapter 17.  Packaging and Distributing Code
      Section 17.1.  Using RDoc
      Section 17.2.  Installation and Packaging
      Section 17.3.  RubyForge and the RAA
      Section 17.4.  Conclusion
        Chapter 18.  Network Programming
      Section 18.1.  Network Servers
      Section 18.2.  Network Clients
      Section 18.3.  Conclusion
        Chapter 19.  Ruby and Web Applications
      Section 19.1.  CGI Programming with Ruby
      Section 19.2.  Using FastCGI
      Section 19.3.  Ruby on Rails
      Section 19.4.  Web Development with Nitro
      Section 19.5.  An Introduction to Wee
      Section 19.6.  Web Development with IOWA
      Section 19.7.  Ruby and the Web Server
      Section 19.8.  Conclusion
        Chapter 20.  Distributed Ruby
      Section 20.1.  An Overview: Using drb
      Section 20.2.  Case Study: A Stock Ticker Simulation
      Section 20.3.  Rinda: A Ruby Tuplespace
      Section 20.4.  Service Discovery with Distributed Ruby
      Section 20.5.  Conclusion
        Chapter 21.  Ruby Development Tools
      Section 21.1.  Using RubyGems
      Section 21.2.  Using Rake
      Section 21.3.  Using irb
      Section 21.4.  The ri Utility
      Section 21.5.  Editor Support
      Section 21.6.  Integrated Development Environments
      Section 21.7.  Conclusion
        Chapter 22.  The Ruby Community
      Section 22.1.  Web Resources
      Section 22.2.  Newsgroup and Mailing Lists
      Section 22.3.  Blogs and Online Magazines
      Section 22.4.  Ruby Change Requests
      Section 22.5.  IRC Channels
      Section 22.6.  Ruby Conferences
      Section 22.7.  Local Ruby Groups
      Section 22.8.  Conclusion
   Index



The Ruby Way(c) Solutions and Techniques in Ruby Programming
The Ruby Way, Second Edition: Solutions and Techniques in Ruby Programming (2nd Edition)
ISBN: 0672328844
EAN: 2147483647
Year: 2004
Pages: 269
Authors: Hal Fulton

Similar book on Amazon

flylib.com © 2008-2017.
If you may any questions please contact us: flylib@qtcs.net