The Well-Grounded Rubyist, 2nd Ed, video edition

Table of contents

1. PART 1 RUBY FOUNDATIONS
   1. Chapter 1. Bootstrapping your Ruby literacy
   2. Chapter 1. The variety of Ruby identifiers
   3. Chapter 1. Method calls, messages, and Ruby objects
   4. Chapter 1. Writing and saving a simple program
   5. Chapter 1. Anatomy of the Ruby installation
   6. Chapter 1. Ruby extensions and programming libraries
   7. Chapter 1. Out-of-the-box Ruby tools and applications
   8. Chapter 1. A closer look at interactive Ruby interpretation with irb
   9. Chapter 1. The rake task-management utility
   10. Chapter 2. Objects, methods, and local variables
   11. Chapter 2. Creating a generic object
   12. Chapter 2. Crafting an object: The behavior of a ticket
   13. Chapter 2. The innate behaviors of an object
   14. Chapter 2. A close look at method arguments
   15. Chapter 2. Order of parameters and arguments
   16. Chapter 2. Local variables and variable assignment
   17. Chapter 2. References in variable assignment and reassignment
   18. Chapter 2. Local variables and the things that look like them
   19. Chapter 3. Organizing objects with classes
   20. Chapter 3. Overriding methods
   21. Chapter 3. Instance variables and object state
   22. Chapter 3. Setter methods
   23. Chapter 3. Attributes and the attr_* method family
   24. Chapter 3. Inheritance and the Ruby class hierarchy
   25. Chapter 3. Classes as objects and message receivers
   26. Chapter 3. A singleton method by any other name...
   27. Chapter 3. Constants up close
   28. Chapter 3. Nature vs. nurture in Ruby objects
   29. Chapter 4. Modules and program organization
   30. Chapter 4. A module encapsulating “stacklikeness”
   31. Chapter 4. Mixing a module into a class
   32. Chapter 4. Modules, classes, and method lookup
   33. Chapter 4. Defining the same method more than once
   34. Chapter 4. The rules of method lookup summarized
   35. Chapter 4. The method_missing method
   36. Chapter 4. Class/module design and naming
   37. Chapter 5. The default object (self), scope, and visibility
   38. Chapter 5. Self inside class, module, and method definitions
   39. Chapter 5. Self as the default receiver of messages
   40. Chapter 5. Determining scope
   41. Chapter 5. Local scope
   42. Chapter 5. Scope and resolution of constants
   43. Chapter 5. Class variable syntax, scope, and visibility
   44. Chapter 5. Class variables and the class hierarchy
   45. Chapter 5. Deploying method-access rules
   46. Chapter 5. Writing and using top-level methods
   47. Chapter 6. Control-flow techniques
   48. Chapter 6. Assignment syntax in condition bodies and tests
   49. Chapter 6. case statements
   50. Chapter 6. Repeating actions with loops
   51. Chapter 6. Iterators and code blocks
   52. Chapter 6. Curly braces vs. do/end in code block syntax
   53. Chapter 6. The importance of being each
   54. Chapter 6. Block parameters and variable scope
   55. Chapter 6. Error handling and exceptions
   56. Chapter 6. Capturing an exception in a rescue clause
2. PART 2 BUILT-IN CLASSES AND MODULES
   1. Chapter 7. Built-in essentials
   2. Chapter 7. Recurrent syntactic sugar
   3. Chapter 7. Bang (!) methods and “danger”
   4. Chapter 7. Built-in and custom to_* (conversion) methods
   5. Chapter 7. Numerical conversion with to_i and to_f
   6. Chapter 7. Boolean states, Boolean objects, and nil
   7. Chapter 7. Comparing two objects
   8. Chapter 7. Inspecting object capabilities
   9. Chapter 8. Strings, symbols, and other scalar objects
   10. Chapter 8. Basic string manipulation
   11. Chapter 8. Querying strings
   12. Chapter 8. String transformation
   13. Chapter 8. String encoding: A brief introduction
   14. Chapter 8. Symbols and their uses
   15. Chapter 8. Symbols in practice
   16. Chapter 8. Numerical objects
   17. Chapter 8. Times and dates
   18. Chapter 8. Date/time formatting methods
   19. Chapter 9. Collection and container objects
   20. Chapter 9. Collection handling with arrays
   21. Chapter 9. Inserting, retrieving, and removing array elements
   22. Chapter 9. Combining arrays with other arrays
   23. Chapter 9. Hashes
   24. Chapter 9. Specifying default hash values and behavior
   25. Chapter 9. Hash querying
   26. Chapter 9. Ranges
   27. Chapter 9. Sets
   28. Chapter 10. Collections central: Enumerable and Enumerator
   29. Chapter 10. Enumerable Boolean queries
   30. Chapter 10. Enumerable searching and selecting
   31. Chapter 10. Selecting on threequal matches with grep
   32. Chapter 10. Element-wise enumerable operations
   33. Chapter 10. Relatives of each
   34. Chapter 10. The map method
   35. Chapter 10. Strings as quasi-enumerables
   36. Chapter 10. Where the Comparable module fits into enumerable sorting (or doesn’t)
   37. Chapter 10. Enumerators and the next dimension of enumerability
   38. Chapter 10. Attaching enumerators to other objects
   39. Chapter 10. Enumerator semantics and uses
   40. Chapter 10. Fine-grained iteration with enumerators
   41. Chapter 10. Enumerator method chaining
   42. Chapter 10. Exclusive-or operations on strings with enumerators
   43. Chapter 10. Lazy enumerators
   44. Chapter 11. Regular expressions and regexp-based string operations
   45. Chapter 11. Building a pattern in a regular expression
   46. Chapter 11. Matching, substring captures, and MatchData
   47. Chapter 11. Two ways of getting the captures
   48. Chapter 11. Fine-tuning regular expressions with quantifiers, anchors, and modifiers
   49. Chapter 11. Greedy (and non-greedy) quantifiers
   50. Chapter 11. Regular expression anchors and assertions
   51. Chapter 11. Converting strings and regular expressions to each other
   52. Chapter 11. Common methods that use regular expressions
   53. Chapter 11. Case equality and grep
   54. Chapter 12. File and I/O operations
   55. Chapter 12. STDIN, STDOUT, STDERR
   56. Chapter 12. Basic file operations
   57. Chapter 12. Reading files with File class methods
   58. Chapter 12. Querying IO and File objects
   59. Chapter 12. Directory manipulation with the Dir class
   60. Chapter 12. File tools from the standard library
   61. Chapter 12. The StringIO class
3. PART 3 RUBY DINAMICS
   1. Chapter 13. Object individuation
   2. Chapter 13. Examining and modifying a singleton class directly
   3. Chapter 13. Singleton classes on the method-lookup path
   4. Chapter 13. The singleton_class method
   5. Chapter 13. Modifying Ruby’s core classes and modules
   6. Chapter 13. The risks of changing core functionality
   7. Chapter 13. Additive changes
   8. Chapter 13. Per-object changes with extend
   9. Chapter 13. BasicObject as ancestor and class
   10. Chapter 14. Callable and runnable objects
   11. Chapter 14. Procs and blocks and how they differ
   12. Chapter 14. Using Symbol#to_proc for conciseness
   13. Chapter 14. Creating functions with lambda and ->
   14. Chapter 14. The eval family of methods
   15. Chapter 14. The instance_eval method
   16. Chapter 14. Parallel execution with threads
   17. Chapter 14. Writing a chat server using sockets and threads
   18. Chapter 14. Manipulating thread keys
   19. Chapter 14. Issuing system commands from inside Ruby programs
   20. Chapter 14. Summary
   21. Chapter 15. Callbacks, hooks, and runtime introspection
   22. Chapter 15. Intercepting unrecognized messages with method_missing
   23. Chapter 15. Trapping include and prepend operations
   24. Chapter 15. The Module#const_missing method
   25. Chapter 15. Interpreting object capability queries
   26. Chapter 15. Getting class and module instance methods
   27. Chapter 15. Introspection of variables and constants
   28. Chapter 15. Tracing execution
   29. Chapter 15. Callbacks and method inspection in practice
   30. Chapter 15. Specifying and implementing MicroTest