The Well-Grounded Rubyist, Third Edition

Table of contents

1. Copyright
2. Brief Table of Contents
3. Table of Contents
4. Praise for the Second Edition
5. Preface
6. Acknowledgments
7. About this book
8. About the authors
9. About the cover illustration
10. Part 1. Ruby foundations
    1. Chapter 1. Bootstrapping your Ruby literacy
       1. 1.1. Basic Ruby language literacy
       2. 1.2. Anatomy of the Ruby installation
       3. 1.3. Ruby extensions and programming libraries
       4. 1.4. Out-of-the-box Ruby tools and applications
       5. Summary
    2. Chapter 2. Objects, methods, and local variables
       1. 2.1. Talking to objects
       2. 2.2. Crafting an object: the behavior of a ticket
       3. 2.3. The innate behaviors of an object
       4. 2.4. A close look at method arguments
       5. 2.5. Local variables and variable assignment
       6. Summary
    3. Chapter 3. Organizing objects with classes
       1. 3.1. Classes and instances
       2. 3.2. Instance variables and object state
       3. 3.3. Setter methods
       4. 3.4. Attributes and the attr_* method family
       5. 3.5. Inheritance and the Ruby class hierarchy
       6. 3.6. Classes as objects and message receivers
       7. 3.7. Constants up close
       8. 3.8. Nature vs. nurture in Ruby objects
       9. Summary
    4. Chapter 4. Modules and program organization
       1. 4.1. Basics of module creation and use
       2. 4.2. Modules, classes, and method lookup
       3. 4.3. The method_missing method
       4. 4.4. Class/module design and naming
       5. Summary
    5. Chapter 5. The default object (self), scope, and visibility
       1. 5.1. Understanding self, the current/default object
       2. 5.2. Determining scope
       3. 5.3. Deploying method-access rules
       4. 5.4. Writing and using top-level methods
       5. Summary
    6. Chapter 6. Control-flow techniques
       1. 6.1. Conditional code execution
       2. 6.2. Repeating actions with loops
       3. 6.3. Iterators and code blocks
       4. 6.4. Error handling and exceptions
       5. Summary
11. Part 2. Built-in classes and modules
    1. Chapter 7. Built-in essentials
       1. 7.1. Ruby’s literal constructors
       2. 7.2. Recurrent syntactic sugar
       3. 7.3. Bang (!) methods and “danger”
       4. 7.4. Built-in and custom to_* (conversion) methods
       5. 7.5. Boolean states, Boolean objects, and nil
       6. 7.6. Comparing two objects
       7. 7.7. Inspecting object capabilities
       8. Summary
    2. Chapter 8. Strings, symbols, and other scalar objects
       1. 8.1. Working with strings
       2. 8.2. Symbols and their uses
       3. 8.3. Numerical objects
       4. 8.4. Times and dates
       5. Summary
    3. Chapter 9. Collection and container objects
       1. 9.1. Arrays and hashes in comparison
       2. 9.2. Collection handling with arrays
       3. 9.3. Hashes
       4. 9.4. Ranges
       5. 9.5. Sets
       6. Summary
    4. Chapter 10. Collections central: Enumerable and Enumerator
       1. 10.1. Gaining enumerability through each
       2. 10.2. Enumerable Boolean queries
       3. 10.3. Enumerable searching and selecting
       4. 10.4. Element-wise enumerable operations
       5. 10.5. Relatives of each
       6. 10.6. The map method
       7. 10.7. Strings as quasi-enumerables
       8. 10.8. Sorting enumerables
       9. 10.9. Enumerators and the next dimension of enumerability
       10. 10.10. Enumerator semantics and uses
       11. 10.11. Enumerator method chaining
       12. 10.12. Lazy enumerators
       13. Summary
    5. Chapter 11. Regular expressions and regexp-based string operations
       1. 11.1. What are regular expressions?
       2. 11.2. Writing regular expressions
       3. 11.3. Building a pattern in a regular expression
       4. 11.4. Matching, substring captures, and MatchData
       5. 11.5. Fine-tuning regular expressions with quantifiers, anchors, and modifiers
       6. 11.6. Converting strings and regular expressions to each other
       7. 11.7. Common methods that use regular expressions
       8. Summary
    6. Chapter 12. File and I/O operations
       1. 12.1. How Ruby’s I/O system is put together
       2. 12.2. Basic file operations
       3. 12.3. Querying IO and File objects
       4. 12.4. Directory manipulation with the Dir class
       5. 12.5. File tools from the standard library
       6. Summary
12. Part 3. Ruby dynamics
    1. Chapter 13. Object individuation
       1. 13.1. Where the singleton methods are: the singleton class
       2. 13.2. Modifying Ruby’s core classes and modules
       3. 13.3. BasicObject as ancestor and class
       4. Summary
    2. Chapter 14. Callable and runnable objects
       1. 14.1. Basic anonymous functions: the Proc class
       2. 14.2. Creating functions with lambda and ->
       3. 14.4. The eval family of methods
       4. 14.5. Concurrent execution with threads
       5. 14.6. Issuing system commands from inside Ruby programs
       6. Summary
    3. Chapter 15. Callbacks, hooks, and runtime introspection
       1. 15.1. Callbacks and hooks
       2. 15.2. Interpreting object capability queries
       3. 15.3. Introspection of variables and constants
       4. 15.4. Tracing execution
       5. 15.5. Callbacks and method inspection in practice
       6. Summary
    4. Chapter 16. Ruby and functional programming
       1. 16.1. Understanding pure functions
       2. 16.2. Immutability
       3. 16.3. Higher-order functions
       4. 16.4. Recursion
       5. Summary
13. Index
14. List of Figures
15. List of Tables
16. List of Listings