Write your own DSL in Ruby Let's do some metaprogramming! Tom de Bruijn – mastodon.social/@tombruijn – tomdebruijn.com 

What is a DSL? ? ? ? 

Domain Speci fi c Language ? ? ? ? ? 

A sub-language in Ruby *
 for a Domain A gem, or as part of an app * DSLs can also be made in other languages 

# Rake example task :hello do puts "Hello there" end 

$ rake hello Hello there 

class Profile < TomsSchemaGem plugin LabelPlugin attribute :name, :label => "Name" attribute :socials do label "Social media" attribute :twitter, :label => "Twitter" attribute :mastodon, :label => "Mastodon" end end profile = Profile.new(...) profile.name.label # => "Name" profile.name.value # => "Tom de Bruijn" profile.socials.twitter.value # => "@tombruijn" 

Why use a DSL? 

Con fi guration 

# config/application.rb module MyApp class Application < Rails::Application config.load_defaults 7.0 config.time_zone = "UTC" config.app.custom_option = "foo" end end 

No YAML required 😌 

Automate writing code Frameworks provide tools to simplify things 

Rails.application.routes.draw do resources :posts do resources :comments end root "homepage#show" end 

Rails.application.routes.draw do resources :posts do resources :comments end root "homepage#show" end resources :posts do resources :comments root "homepage#show" 

Create routes resources :posts • GET /posts • GET /posts/:id • POST /posts • PUT /posts/:id • DELETE /posts/:id 

Point to the right controller 

class User < ApplicationRecord validates :name, :presence => true end 

Validation validates :name, :presence => true • Validation on creation • Validation on update • Validation on demand • Storing error messages 

No updating 5 locations for every change 

Make high churn code more maintainable 

case ARGV.first when "hello" puts "Hello world" when "bye" puts "Goodbye world" end # ruby tasks.rb hello task :hello do puts "Hello world" end task :bye do puts "Goodbye world" end # rake hello 

How to write your own DSL? 

config = Config.new( :verbose => true, :format => :documentation ) 

config = Config.new config.verbose = true config.format = :documentation 

class Config attr_accessor :verbose, :format end config = Config.new config.verbose = true config.format = :documentation pp config # => # 

class Config attr_accessor :verbose, :format end config = Config.new config.verbose = true config.format = :documentation pp config # => # attr_accessor :verbose, :format config.verbose = true config.format = :documentation # => # 

config = Config.new config.verbose = true config.format = :documentation pp config.options # => {:verbose=>true, :format=>:documentation} 

class Config attr_reader :options def initialize @options = {} end def verbose=(value) @options[:verbose] = value end def format=(value) @options[:format] = value end end 

class Config attr_reader :options def initialize @options = {} end def verbose(value) @options[:verbose] = value end def format(value) @options[:format] = value end end def verbose=(value) @options[:verbose] = value end def format=(value) @options[:format] = value end 

New problem: Create methods for every new option def format=(value) @options[:format] = value end def enabled=(value) @options[:enabled] = value end def fail_fast=(value) @options[:fail_fast] = value end def verbose=(value) @options[:verbose] = value end def format=(value) @options[:format] = value end def enabled=(value) @options[:enabled] = value end def fail_fast=(value) @options[:fail_fast] = value end def verbose=(value) @options[:enabled] = value end def fail_fast=(value) @options[:fail_fast] = value end def verbose=(value) @options[:verbose] = value end def format=(value) @options[:format] = value end def enabled=(value) @options[:enabled] = value end def fail_fast=(value) @options[:fail_fast] = value end def verbose=(value) @options[:verbose] = value end def format=(value) @options[:format] = value end def format=(value) @options[:format] = end def enabled=(value) @options[:enabled] end def fail_fast=(value) @options[:fail_fast end def verbose=(value) @options[:verbose] end def format=(value) @options[:format] = end def enabled=(value) @options[:enabled] end def fail_fast=(value) @options[:fail_fast end def verbose=(value) @options[:verbose] 

Making it more dynamic with ✨ method_missing ✨ 

def method_missing(method_name, *args) [method_name.to_s, *args] end puts welcome to this talk about dsls # welcome # to # this # talk # about # dsls 

class Config # ... def method_missing(method_name, value) if method_name.end_with? "=" @options[method_name[0..-1]] = value else super # Fall back behavior end end end config = Config.new config.verbose = true config.format = :documentation 

method_missing may not
 be a good choice 

What if you call the
 missing method wrong? 

class Config def method_missing(method_name, value) # ... end end config = Config.new config.verbose # => `method_missing': # wrong number of arguments (given 1, 
 expected 2) (ArgumentError) 

Unclear where
 methods are de fi ned 

Breaks respond_to? 

config = Config.new config.verbose = true pp config.respond_to? :verbose= # => false 

Dynamically de fi ne
 con fi g option methods 

class Config def self.def_options(*option_names) option_names.each do |option_name| define_method "#{option_name}=" do |value| options[option_name] = value end end end def_options :verbose, :format # ... end config = Config.new config.verbose = true config.format = :documentation 

class Config def self.def_options(*option_names) option_names.each do |option_name| define_method "#{option_name}=" do |value| options[option_name] = value end end end def_options :verbose, :format # ... end config = Config.new config.verbose = true config.format = :documentation def_options :verbose, :format 

class Config def self.def_options(*option_names) option_names.each do |option_name| define_method "#{option_name}=" do |value| options[option_name] = value end end end def_options :verbose, :format # ... end config = Config.new config.verbose = true config.format = :documentation def self.def_options(*option_names) option_names.each do |option_name| 

class Config def self.def_options(*option_names) option_names.each do |option_name| define_method "#{option_name}=" do |value| options[option_name] = value end end end def_options :verbose, :format # ... end config = Config.new config.verbose = true config.format = :documentation define_method "#{option_name}=" do |value| options[option_name] = value end 

⚡ Blocks! ⚡ 

Config.configure do |config| config.verbose = true config.format = :documentation end 

class Config def self.configure instance = new yield instance instance end # ... end 

class Config def self.configure instance = new yield instance instance end # ... end def self.configure 

class Config def self.configure instance = new yield instance instance end # ... end instance = new 

class Config def self.configure instance = new yield instance instance end # ... end yield instance 

Config.configure do |config| config.verbose = true config.format = :documentation end |config| config. config. 

Config.configure do |config| config.verbose = true config.format = :documentation end 

Config.configure do verbose true format :documentation end 

class Config def self.configure(&block) instance = new instance.instance_eval(&block) instance end # ... end 

class Config def self.configure(&block) instance = new instance.instance_eval(&block) instance end # ... end def self.configure(&block) 

class Config def self.configure(&block) instance = new instance.instance_eval(&block) instance end # ... end instance.instance_eval(&block) 

Config.configure do verbose true format :documentation end 

# This won't work! # Ruby will think you're assigning # local variables Config.configure do verbose = true format = :documentation end 

Config.configure do self.verbose = true self.format = :documentation end self.verbose = self.format = 

Config.configure do verbose true format :documentation end 

When to use one or the other? 

Config.configure do |config| config.verbose = true # Set a value end Config.configure do load_defaults! # Perform an action end 

# config/puma.rb workers 3 preload_app! 

Our tools so far •Dynamically de fi ne methods •Ruby blocks 

Share DSL behavior with modules 

# Multiple configuration classes Config.configure do enabled true end Output.configure do verbose true format :documentation end 

class Config include Configurable def_options :enabled end class Output include Configurable def_options :verbose, :format end 

module Configurable def self.included(base) base.extend ClassMethods end module ClassMethods def def_options(*option_names) # ... end def configure(&block) # ... end end # ... 

Config.configure do enabled true output do verbose true format :documentation end end 

class Config include Configurable def_options :enabled class Output include Configurable def_options :verbose, :format end def output(&block) @output ||= Output.new @output.instance_eval(&block) if block_given? @output end end 

class Config include Configurable def_options :enabled class Output include Configurable def_options :verbose, :format end def output(&block) @output ||= Output.new @output.instance_eval(&block) if block_given? @output end end def output(&block) @output ||= Output.new @output.instance_eval(&block) if block_given? @output end 

Module builder pattern dejimata.com/2017/5/20/the-ruby-module-builder-pattern 

class Config include ConfigOption.define(:verbose, :format) end 

class Config def self.def_options(*option_names) option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end end def_options :verbose, :format # ... end 

module ConfigOption def self.define(*option_names) Module.new do def options @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end end 

module ConfigOption def self.define(*option_names) Module.new do def options @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end end def self.define(*option_names) 

module ConfigOption def self.define(*option_names) Module.new do def options @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end end define_method option_name do |value| options[option_name] = value end 

module ConfigOption def self.define(*option_names) Module.new do def options @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end end Module.new do end 

class Config include ConfigOption.define(:verbose, :format) end 

Advantage:
 Easy to reuse everywhere 

Advantage:
 No con fi g option de fi nition logic in the class itself 

# Anonymous module pp Config.included_modules # => [#, Kernel] 

class Config include ConfigOption.new(:verbose, :format) end 

class Config include ConfigOption.new(:verbose, :format) end new 

class ConfigOption < Module def initialize(*option_names) define_method :options do @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end 

class ConfigOption < Module def initialize(*option_names) define_method :options do @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end class ConfigOption < Module 

class ConfigOption < Module def initialize(*option_names) define_method :options do @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end def initialize(*option_names) 

class ConfigOption < Module def initialize(*option_names) define_method :options do @options ||= {} end option_names.each do |option_name| define_method option_name do |value| options[option_name] = value end end define_method :options do @options ||= {} end define_method option_name do |value| options[option_name] = value end 

# Anonymous module pp Config.included_modules # => [#, Kernel] # Named module pp Config.included_modules # => [#, Kernel] 

Read this post: dejimata.com/2017/5/20/the-ruby-module-builder-pattern 

Create DSL objects Keep the DSL and created object separate 

class Config def self.configure(&block) dsl = ConfigDSL.dsl(&block) new(dsl.options) end # ... end Config.configure do verbose true format :documentation end class ConfigDSL include ConfigOption.new( :verbose, :format) def self.dsl(&block) instance = new instance .instance_eval(&block) instance end end 

class Config def self.configure(&block) dsl = ConfigDSL.dsl(&block) new(dsl.options) end # ... end Config.configure do verbose true format :documentation end class ConfigDSL include ConfigOption.new( :verbose, :format) def self.dsl(&block) instance = new instance .instance_eval(&block) instance end end dsl = ConfigDSL.dsl(&block) new(dsl.options) class ConfigDSL def self.dsl(&block) 

Make small modules, like plugins Small modules are easier to maintain than very large classes 

class Profile < TomsSchemaGem plugin LabelPlugin attribute :name, :label => "Name" attribute :socials do label "Social media" attribute :twitter, :label => "Twitter" attribute :mastodon, :label => "Mastodon" end end profile = Profile.new(...) profile.name.label # => "Name" profile.name.value # => "Tom de Bruijn" profile.socials.twitter.value # => "@tombruijn" 

class Profile < TomsSchemaGem plugin LabelPlugin attribute :name, :label => "Name" attribute :socials do label "Social media" attribute :twitter, :label => "Twitter" attribute :mastodon, :label => "Mastodon" end end profile = Profile.new(...) profile.name.label # => "Name" profile.name.value # => "Tom de Bruijn" profile.socials.twitter.value # => "@tombruijn" plugin LabelPlugin label "Social media" profile.name.label # => "Name" 

class Profile < TomsSchemaGem plugin LabelPlugin attribute :name, :label => "Name" attribute :socials do label "Social media" profile.name.label # => "Name" plugin LabelPlugin :label => "Name" label "Social media" profile.name.label # => "Name" 

module LabelPlugin < PluginDSL option :label attribute_method :label do options[:label] end end 

In summary • method_missing • de fi ne_method • Ruby blocks • yield • instance_eval • Modules • share behavior between classes • Module builder pattern • DSL objects - move DSL logic to separate classes • Create plugins 

Now go forth and make your DSL! 

Thank you! Do something nice for someone that’s not yourself. Join a union. DSL DS DSL Tom de Bruijn – mastodon.social/@tombruijn – tomdebruijn.com