Ruby Trainer

Where Ruby sits in an automation toolchain and why so much infrastructure tooling is written in it. Installation and version management, the REPL as a working tool, and a first pass through syntax with the deliberate framing that a Chef recipe or Vagrantfile is just Ruby.

Topics: Why Ruby underpins Chef, Vagrant, Puppet extensions and Fluentd plugins · Installing Ruby and managing versions with rbenv or rvm · irb and pry as working tools, not demos · Basic syntax, literals and string interpolation · Symbols versus strings and why the distinction matters · Truthiness, nil, and the comparison operators · Reading an existing Vagrantfile line by line

• Assignments: (1) Install a managed Ruby and prove you can switch versions per project; (2) Annotate a real Vagrantfile, identifying every Ruby construct in it
• Capstone: Take a piece of automation code from your own estate and explain every line of it in writing

Everything is an object, and understanding what that actually means. Classes, instances, instance variables and accessors, inheritance, and the method lookup path that explains why a mixed-in module sometimes wins and sometimes does not.

Topics: Everything is an object: integers, nil, classes themselves · Defining classes, initialize and instance variables · attr_reader, attr_writer and attr_accessor · Public, private and protected methods · Inheritance, super and the ancestors chain · Class methods, class variables and class-level state · Open classes and monkey patching — power and consequence · Duck typing and respond_to?

• Assignments: (1) Model a small infrastructure inventory as classes with proper encapsulation; (2) Trace the ancestors chain of a class from a real gem and explain the lookup order
• Capstone: Build a small object model for a real operational domain, with inheritance justified rather than assumed

The calling convention in full, because DSLs live or die on it. Default parameter values, variable-length parameter lists, keyword arguments, method aliasing, operators as methods, and the message-passing model that makes method_missing possible.

Topics: Default parameter values · Variable length parameter lists with splat · Keyword arguments and double splat · Argument ordering rules and the errors they produce · Method aliasing and alias_method · Operators as methods, and defining your own · Method calls as messages: send and public_send · method_missing and respond_to_missing?

• Assignments: (1) Refactor a method with a five-argument positional signature into keyword arguments; (2) Implement a proxy object using method_missing that logs every call it forwards
• Capstone: Design a method interface for an automation library that is hard to call incorrectly

The construct that makes Ruby feel like Ruby. Passing blocks, yield, block local variables, capturing a block as a proc, lambdas and their differing arity and return semantics, and closures over surrounding scope — the mechanism behind every configuration block you have ever written.

Topics: Blocks and yield · block_given? and optional blocks · Block local variables and scope leakage · Using blocks for resource management and ensure · From block to proc with the ampersand · Lambdas and the arity and return differences from procs · Using procs and lambdas as stored behaviour · Closures and captured scope

• Assignments: (1) Write a method that takes a block and guarantees cleanup even when the block raises; (2) Demonstrate every behavioural difference between a proc and a lambda in runnable code
• Capstone: Implement a block-based configuration API that reads like a DSL and validates its input

One vocabulary across every collection type. Arrays, hashes, ranges and sets, then Enumerable as the interface that unifies them — map, select, reduce, group_by, each_with_object — and how to make your own class enumerable by defining a single method.

Topics: Arrays, hashes, ranges and sets · Hash defaults, nested access and dig · map, select, reject, find and detect · reduce, inject and each_with_object · group_by, partition, sort_by and min_by · Lazy enumerators for large or infinite sequences · Making a custom class Enumerable · Comparable and the spaceship operator

• Assignments: (1) Transform a nested YAML inventory into a grouped report using only Enumerable methods; (2) Make a custom collection class Enumerable and Comparable
• Capstone: Build a data transformation pipeline over real operational data with no explicit index loops

Composition without multiple inheritance. Constants and their lookup rules, modules as namespaces and as mixins, include versus extend versus prepend, and the module patterns that structure large automation codebases.

Topics: Constants, constant lookup and reassignment warnings · Modules as namespaces · Modules as mixins with include · extend for adding class-level behaviour · prepend and the method wrapping it enables · module_function and utility modules · Resolving conflicts between multiple mixins · Composition versus inheritance in real automation code

• Assignments: (1) Extract shared behaviour from three classes into a mixin without breaking any of them; (2) Use prepend to wrap an existing method with logging, leaving the original intact
• Capstone: Refactor a flat script into namespaced modules with mixins carrying the shared behaviour

The chapter that makes configuration management stop being magic. define_method, instance_eval and instance_exec, the singleton class, class macros, and a line-by-line reconstruction of how a Chef resource block or a Vagrant configure block is evaluated.

Topics: define_method and dynamically generated methods · instance_eval, instance_exec and changing self · class_eval and defining behaviour at runtime · The singleton class and per-object methods · Class macros: writing your own attr_accessor · Hooks: inherited, included, method_added · Building a small internal DSL from scratch · When metaprogramming is the wrong answer

• Assignments: (1) Implement your own attr_accessor equivalent using define_method; (2) Build a five-keyword DSL that configures an object through instance_eval
• Capstone: Write a working miniature configuration DSL and explain how it maps to Chef's resource model

The parts an automation script actually spends its time on. Exceptions and the exception hierarchy, retry and ensure, reading and writing files, shelling out safely, environment and arguments, and parsing the YAML and JSON that infrastructure code lives on.

Topics: begin, rescue, ensure, retry and raise · The exception hierarchy and defining custom exceptions · Rescuing narrowly and why rescuing StandardError broadly hurts · File and Dir operations, Pathname and FileUtils · Running external commands: backticks, system, Open3 · Command injection risks and safe argument passing · ENV, ARGV and OptionParser for CLI tools · YAML, JSON and ERB templating

• Assignments: (1) Write a CLI tool with OptionParser that reads YAML config and fails with useful messages; (2) Replace an unsafe backtick call with Open3 and prove the injection is closed
• Capstone: Build a command-line automation tool that templates configuration files from a YAML inventory

Putting Ruby to work beyond a single script. Project layout conventions, require and the load path, RubyGems, Bundler and the Gemfile.lock, version constraints, and the private gem hosting most organisations end up needing.

Topics: Project layout: lib, bin, spec and the load path · require, require_relative and autoloading · RubyGems: finding, installing and inspecting gems · Bundler, Gemfile and Gemfile.lock · Version constraints and the pessimistic operator · Reading the source of a gem you depend on · Private gem sources and internal hosting · Vendoring and reproducible builds in CI

• Assignments: (1) Convert a single-file script into a properly structured project with Bundler; (2) Pin and audit a dependency tree, then explain each constraint you chose
• Capstone: Deliver a reproducible Ruby project that builds identically on a colleague's machine and in CI

Testing frameworks and what to test when the code changes servers. Minitest and RSpec, describe/it structure, mocks and stubs, fixtures, and the infrastructure-specific layers — ChefSpec, ServerSpec, Test Kitchen — that verify automation without waiting for a real host.

Topics: Minitest and RSpec compared · describe, context, it and expectation syntax · Test doubles: mocks, stubs and spies · Fixtures, factories and test data · Testing code that shells out or touches the filesystem · ChefSpec for unit-testing recipes · ServerSpec and Test Kitchen for convergence testing · Running tests in CI and enforcing coverage sensibly

• Assignments: (1) Write RSpec specs for a class that shells out, without executing the command; (2) Add ChefSpec coverage to an existing recipe and catch a real defect with it
• Capstone: Deliver a tested automation library with unit tests in CI and convergence tests against a disposable host

Finding out what the code actually did, then shipping it. Debugging tools and breakpoints, reading backtraces properly, inspecting live objects, profiling and memory, then packaging and distributing code as a gem with a version and a changelog.

Topics: The debug gem and pry: breakpoints, stepping, inspecting state · Reading a backtrace and finding the real origin · Logger, log levels and useful diagnostic output · ObjectSpace and inspecting live objects · Benchmarking and profiling hot paths · Memory growth and common leak patterns in long-running scripts · Building a gem: gemspec, versioning and dependencies · Packaging and distributing code internally or on RubyGems

• Assignments: (1) Debug a failing script entirely from a breakpoint session rather than by adding print statements; (2) Package a working tool as a gem and install it from a private source
• Capstone: Publish an internal gem with a gemspec, semantic version, tests and a documented upgrade path

Bringing it back to the tools. Writing Chef custom resources and libraries, extending Puppet with facts and functions, dynamic Vagrantfiles, Fluentd filter plugins, Rake task automation, and calling cloud and internal APIs from Ruby.

Topics: Chef custom resources, libraries and helper modules · Puppet custom facts, functions and providers in Ruby · Dynamic Vagrantfiles driven from an inventory file · Writing a Fluentd filter or output plugin · Rake tasks, dependencies and namespaces for operational work · ERB templates for configuration generation · HTTP clients and calling cloud provider APIs · Deciding between Ruby, Python and shell for a given automation job

• Assignments: (1) Write a Chef custom resource with a supporting library module and use it in a recipe; (2) Build a Rake file that automates three real operational tasks with dependencies
• Capstone: Deliver a piece of production-grade Ruby automation that extends a tool your team already runs