DSLs in Ruby
Wow, Do We All Get a Language?
Dave Burt
Melbourne Ruby Nuby Night
28 June 2007
Ruby's cool, but it's not for everybody.
Sometimes you just want to write in a language that is tailored to the problem you're dealing with.
What is a DSL?
- Not a general-purpose language
- No inscrutable, arcane syntax or geek-speak
- Not verbose or unwieldy for domain problems
- Domain-Specific Programming Language
- Uses terms that are packed with meaning in the context of the domain
- Therefore, concisely describes problems/solutions in that area
A DSL — Rubix Cube Moves
- FD'F'R'D2R
Describes a set of steps to change a Rubix Cube.
Is it a programming language? Yes, it clearly and unambiguously describes an algorithm.
You could programmatically change a virtual cube, or instruct a robot how to move a real one, or display clear instructions to a user...
A DSL — HR Management
- with Employee("123-45-6789") do dock_salary 1000 warn_about :misconduct end
No extraneous language; any HR Manager can read this.
It's also valid Ruby code.
A DSL — Dungeon
- class Dragon < Creature life 1340 # tough scales strength 451 # bristling veins charisma 1020 # toothy smile weapon 939 # fire breath end
You can imagine what this does in the context of describing a dungeon.
It's Ruby, too.
A DSL — Database table definition
- create_table :updates { foreign_key :user foreign_key :group text :body string :type timestamps! }
SQL is another DSL.
This is valid Ruby code; it's a DSL that does the same thing as SQL DDL.
A DSL — HTML templating
- html { head { title action_name stylesheet_link_tag "scaffold" } body { p flash[:notice], :style => "color: green" div @content_for_layout, :id => "content" } }
HTML is another DSL.
This is valid Ruby code; it's a DSL that could be compared to PHP -- leveraging programmability from Ruby but still focused on clearly describing a document
A DSL — Invoicing
- new_invoice do address 'Test Client, Street, ZIP' code '2006-45' date '3rd Oct' at_rate 50 do spent 3.hours_on('Morning meeting') spent 0.5.hours_on('Making the coffee for the boss').on('3rd Sept') end end
Still Ruby, still clear and concise, using domain-specific language almost exclusively.
A DSL — Workflow
- route "Problems" do step "Problem Resolution" end route "EMail Order" do step "Validate Customer" step "Assemble Order" step "Charge Credit Card" do on "invalid", :route => "Problems", :step => "Problem Resolution" end step "Ship" end
You can see a fairly complex construct can be described naturally if you are using the right language.
Types of DSL
- Brand new language
- Existing language, extended
A DSL — DOT
- digraph G { main -> parse -> execute; main -> init; main -> cleanup; execute -> make_string; execute -> printf init -> make_string; main -> printf; execute -> compare; }
With a new language, you can have exactly any syntax you imagine to be ideal.
But you have to build your own parser and interpreter. (Though there are tools to help you do this, such as Ruby's Racc and Parser, Unix's yacc and bison, etc.)
This is the DOT language for describing directed graphs. This code produces the graph below when interpreted. (Ruby's RDoc tool uses this to describe class heirarchies graphically.)
A DSL — Rake
- task :all => ['hello'] file 'main.o' => ["main.c", "greet.h"] do sh "cc -c -o main.o main.c" end file 'greet.o' => ['greet.c'] do sh "cc -c -o greet.o greet.c" end file "hello" => ["main.o", "greet.o"] do sh "cc -o hello main.o greet.o" end
If you're building on an existing language, you can utilise features of the host language.
Rake describes interdependent tasks and required files; the steps to perform and build them, respectively, are written in Ruby code.
How to make a DSL
- Write code in the language
- Make it do what you want it to
- What?
- How?
Let's make a potentially useful DSL now.
Write code in the language
- slideshow { slide ("DSLs in Ruby") { } slide ("Types of DSL") { item "Brand new language" item "Existing language, extended" } slide ("How to make a DSL") { item "Write code in the language" item "Make it do what you want it to" } }
We want to describe a slideshow just like this.
We've made sure We're using valid Ruby syntax.
Make it do what you want it to
- What do we want it to do?
- Generate XHTML like this slideshow here
- How will we make that happen?
- Running the program using the Ruby interpreter will dump the XHTML on standard output
We could write an interpreter that displays the slideshow interactively, but for simplicity, we'll convert it into a slideshow format that can be displayed in a browser (using Eric Meyer's S5 format).
To do this, we'll make a library we can require in the slideshow definition that will make the code we've already written produce XHTML on STDOUT when executed.
Make it do what you want it to
- def slideshow puts SLIDESHOW_START yield puts SLIDESHOW_END end def slide title puts " <div class='slide'>" puts " <h1>#{ title }</h1>" puts " <ul>" yield puts " </ul>" puts " </div>" end def item text puts " <li>#{ text.htmlspecialchars }</li>" end
This part is no more difficult than writing code in the new language.
We just need to define the words the DSL uses; in this case, three methods will do.
I've left a couple of string constants and a new string instance method to be defined.
Make it do what you want it to
- SLIDESHOW_START = <<END <html> <head>...</head> <body> <div class='presentation'> END SLIDESHOW_END = <<END </div> </body> </html> END class String def htmlspecialchars gsub('&', '&').gsub('<', '<').gsub('>', '>') end end
Here are the missing definitions, but this part is obvious and unenlightening.
Done
- We've designed our new slideshow language
- We've implemented it
- All we need to do is run it
- slideshow.rb (pastie)
- my_presentation.rb (pastie)
my_presentation.rb > my_presentation.html- my_presentation.html (pastie)
After adding the line "require 'slideshow'" to the top of my_presentation.rb, it becomes a Ruby program.
We run that program and dump its output into an HTML file.
That HTML file can be displayed just like this one.
References
- Jamis Buck, Writing Domain Specific Languages 2006 blog post
- Jim Freeze, Creating DSLs with Ruby, 2006 Ruby Code & Style article
- Jim Freeze, What is a DSL? 2005 blog post
- Jim Weirich, Speaking the Lingo: Creating Domain Specific Languages in Ruby RubyConf 2005 presentation
- why the lucky stiff, Wow, Do We All Get a Language? 2005 blog post
- why the lucky stiff, Dwemthy's Array