Ruby Advanced Topics — DSLs, Macros, and Internals for Expert-Level Ruby

In this tutorial, you will learn about Ruby Advanced Topics. We cover key concepts, practical examples, and best practices to help you master this topic.

Ruby advanced topics cover DSL creation with class-level macros, Ruby internals including AST and bytecode, C extensions, and JRuby/TruffleRuby differences.

What You'll Learn

• Building DSLs with class-level macros
• Ruby internals: AST, YARV bytecode
• C extensions for Ruby
• JRuby and TruffleRuby differences

Why It Matters

Advanced Ruby is used by gem authors, framework developers, and performance engineers. Rails, RSpec, and Sidekiq use these patterns. DodaZIP uses C extensions for performance.

Real-World Use

Framework development, performance optimization, DSL creation, gem authoring, platform migration.

flowchart LR
    A["Advanced Topics"] --> B["DSLs"]
    A --> C["Internals"]
    A --> D["C Extensions"]
    A --> E["Platforms"]
    A:::current --> B
    style A fill:#2563eb,stroke:#2563eb,color:#fff
    style B fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style C fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style D fill:#dbeafe,stroke:#2563eb,color:#1e40af
    style E fill:#f1f5f9,stroke:#94a3b8,color:#64748b

Building a DSL

class Router
  class << self
    def routes
      @routes ||= []
    end

    def get(path, to:)
      routes << { method: "GET", path: path, handler: to }
    end

    def post(path, to:)
      routes << { method: "POST", path: path, handler: to }
    end
  end
end

class App < Router
  get "/users", to: "users#index"
  post "/users", to: "users#create"
  get "/users/:id", to: "users#show"
end

App.routes.each { |r| puts "#{r[:method]} #{r[:path]} -> #{r[:handler]}" }
# GET /users -> users#index
# POST /users -> users#create
# GET /users/:id -> users#show

Class-Level Macros

class ApplicationRecord
  def self.validates(field, **options)
    define_method("validate_#{field}") do
      value = send(field)
      if options[:presence] && (value.nil? || value.empty?)
        errors.add(field, "can't be blank")
      end
      if options[:numericality] && !value.is_a?(Numeric)
        errors.add(field, "must be numeric")
      end
    end
  end

  def self.before_save(*methods)
    @callbacks ||= []
    @callbacks.concat(methods)
  end

  def save
    self.class.instance_variable_get(:@callbacks)&.each { |cb| send(cb) }
    puts "Saving..."
  end
end

class User < ApplicationRecord
  validates :email, presence: true
  validates :age, numericality: true
  before_save :normalize_email

  attr_accessor :email, :age

  def errors
    @errors ||= []
  end

  private

  def normalize_email
    self.email = email&.downcase&.strip
  end
end

Ruby Internals

# AST (Abstract Syntax Tree)
require "ripper"

code = "1 + 2 * 3"
pp Ripper.sexp(code)
# [:program,
#  [:binary,
#   [:@int, "1", [1, 0]],
#   :+,
#   [:binary,
#    [:@int, "2", [1, 4]],
#    :*,
#    [:@int, "3", [1, 8]]]]]

# YARV Bytecode
require "pp"
code = RubyVM::InstructionSequence.compile("def add(a, b) = a + b")
puts code.disasm

C Extension

// ext/my_extension/my_extension.c
#include "ruby.h"

static VALUE my_method(VALUE self) {
  return rb_str_new2("Hello from C!");
}

void Init_my_extension(void) {
  rb_define_global_function("my_method", my_method, 0);
}

# ext/my_extension/extconf.rb
require "mkmf"
create_makefile("my_extension")

TracePoint

trace = TracePoint.new(:call) do |tp|
  puts "Called: #{tp.defined_class}##{tp.method_id}"
end

trace.enable

def hello = "world"
hello
# Called: Object#hello

Common Mistakes

1. Over-engineering DSLs

Don't create a DSL for everything. Use clean method calls unless the DSL provides clear benefits.

2. Ignoring Thread Safety

C extensions must be thread-safe. Use GVL-aware patterns. Ruby 3+ Ractor-safe extensions require explicit annotation.

3. Monkey-patching Core Classes

Modifying String, Array, or Hash globally can break gems. Use Refinements for scoped changes.

4. Not Testing on Multiple Rubies

Test on MRI, JRuby, and TruffleRuby. Use GitHub Actions matrix builds for CI.

5. Memory Leaks in C Extensions

Always free allocated memory in C extensions. Use xmalloc and xfree from Ruby API.

Practice Questions

1. What is a DSL in Ruby? A Domain-Specific Language built using Ruby syntax. Examples: RSpec's describe/it, Rails routes, Rake tasks.

2. What is YARV? Yet Another Ruby VM — the bytecode Interpreter in MRI Ruby 1.9+. Compiles Ruby to bytecode for execution.

3. What are Refinements? Scoped monkey-patching. Changes are limited to the scope where the refinement is activated.

4. What is the difference between MRI and JRuby? MRI has C API, GIL, YARV VM. JRuby runs on JVM, has true threading, and can use Java libraries.

Challenge: Create a simple DSL for defining validation rules on a model class.

class Validator
  def self.validate(name, &block)
    validations[name] = block
  end

  def self.validations
    @validations ||= {}
  end

  def initialize(object)
    @object = object
  end

  def valid?
    self.class.validations.all? do |name, block|
      instance_exec(@object.send(name), &block)
    end
  end
end

class UserValidator < Validator
  validate :email { |v| v.include?("@") }
  validate :age { |v| v.is_a?(Integer) && v > 0 }
end

FAQ

{{< faq question="What Ruby implementation should I use for production?" >}} MRI (CRuby) is the standard for production. JRuby for Java ecosystem integration. TruffleRuby for peak performance in long-running processes. {{< /faq >}}

{{< faq question="How do I write a C extension?" >}} Use the Ruby C API. Create extconf.rb with create_makefile. The rice gem provides a C++ wrapper for Ruby C API. {{< /faq >}}

{{< faq question="What is the Ruby VM architecture?" >}} Ruby source is parsed into AST, compiled to YARV bytecode, executed by the virtual machine. The GIL prevents parallel execution in MRI. {{< /faq >}}

{{< faq question="What are TracePoints used for?" >}} Debugging, profiling, performance monitoring, and security auditing. Hook into method calls, class definitions, exceptions, and line execution. {{< /faq >}}

{{< faq question="How does Ruby compare to Python for advanced use?" >}} Ruby's blocks and Metaprogramming make DSLs more natural. Python has better scientific computing. Both support C extensions. Choose based on ecosystem needs. {{< /faq >}}

Try It Yourself

require "ripper"

code = <<~RUBY
  def factorial(n)
    n <= 1 ? 1 : n * factorial(n - 1)
  end
RUBY

puts Ripper.sexp(code).inspect

Expected output — AST representation of the factorial method showing program, def, and binary operations.

What's Next

Now that you've completed Ruby 50, you've mastered the language. Consider exploring Go or Rust for systems programming.