Reflexive Metaprogramming in Ruby

1. Reflexive Metaprogramming in Ruby H. Conrad Cunningham Computer and Information Science University of Mississippi

2. Metaprogramming Metaprogramming: writing programs that write or manipulate programs as data Reflexive metaprogramming: writing programs that manipulate themselves as data

3. Reflexive Metaprogramming Languages • Early • Lisp • Smalltalk • More recent • Ruby • Python • Groovy

4. Basic Characteristics of Ruby(1 of 2) • Interpreted • Purely object-oriented • Single inheritance with mixins • Garbage collected • Dynamically, but strongly typed • “Duck typed” • Message passing (to methods)

5. Basic Characteristics of Ruby (2 of 2) • Flexible syntax • optional parentheses on method calls • variable number of arguments • two block syntax alternatives • symbol data type • String manipulation facilities • regular expressions • string interpolation • Array and hash data structures

6. Why Ruby Supportive of Reflexive Metaprogramming (1 of 2) • Open classes • Executable declarations • Dynamic method definition, removal, hiding, and aliasing • Runtime callbacks for • program changes (e.g. method_added) • missing methods (missing_method)

7. Why Ruby Supportive of Reflexive Metaprogramming (2 of 2) • Dynamic evaluation of strings as code • at module level for declarations (class_eval) • at object level for computation (instance_eval) • Reflection (e.g. kind_of?, methods) • Singleton classes/methods for objects • Mixin modules (e.g. Enumerable) • Blocks and closures • Continuations

8. Employee Class HierarchyInitialization class Employee @@nextid = 1 def initialize(first,last,dept,boss) @fname = first.to_s @lname = last.to_s @deptid = dept @supervisor = boss @empid = @@nextid @@nextid = @@nextid + 1 end

9. Employee Class HierarchyWriter Methods def deptid=(dept) # deptid = dept @deptid = dept end def supervisor=(boss) @supervisor = boss end

10. Employee Class HierarchyReader Methods def name # not an attribute @lname + ", " + @fname end def empid; @empid; end def deptid; @deptid; end def supervisor @supervisor end

11. Employee Class HierarchyString Conversion Reader def to_s @empid.to_s + " : " + name + " : " + @deptid.to_s + " (" + @supervisor.to_s + ")" end end # Employee

12. Employee Class HierarchyAlternate Initialization class Employee @@nextid = 1 attr_accessor :deptid, :supervisor attr_reader :empid def initialize(first,last,dept,boss) # as before end

13. Employee Class HierarchyOtherReader Methods def name @lname + ", " + @fname end def to_s @empid.to_s + " : " + name + " : " + @deptid.to_s + " (" + @supervisor.to_s + ")" end end # Employee

14. Employee Class HierarchyStaff Subclass class Staff < Employee attr_accessor :title def initialize(first,last,dept, boss,title) super(first,last,dept,boss) @title = title end def to_s super.to_s + ", " + @title.to_s end end # Staff

15. Employee Class HierarchyUsing Employee Classes class TestEmployee def TestEmployee.do_test @s1 = Staff.new("Robert", "Khayat", "Law", nil, "Chancellor") @s2 = Staff.new("Carolyn", "Staton", "Law", @s1,"Provost") puts "s1.class ==> " + @s1.class.to_s puts "s1.to_s ==> " + @s1.to_s puts "s2.to_s ==> " + @s2.to_s @s1.deptid = "Chancellor" puts "s1.to_s ==> " + @s1.to_s puts "s1.methods ==> " + @s1.methods.join(", ") end end # TestEmployee

16. Employee Class HierarchyTestEmployee.do_test Output irb irb(main):001:0> load "Employee.rb" => true irb(main):002:0> TestEmployee.do_test s1.class ==> Staff s1.to_s ==> 1 : Khayat, Robert : Law (), Chancellor s2.to_s ==> 2 : Staton, Carolyn : Law (1 : Khayat, Robert : Law (), Chancellor), Provost s1.to_s ==> 1 : Khayat, Robert : Chancellor (), Chancellor s1.methods ==> to_a, respond_to?, display, deptid, type, protected_methods, require, deptid=, title, … kind_of? => nil

17. Ruby MetaprogrammingClass Macros • Every class has Class object where instance methods reside • Class definition is executable • Class Class extends class Module • Instance methods of class Module available during definition of classes • Result is essentially “class macros”

18. Ruby MetaprogrammingCodeString Evaluation class_eval instance method ofclass Module • evaluates string as Ruby code • using context of class Module • enabling definition of new methods and constants instance_eval instance method of class Object • evaluates string as Ruby code • using context of the object • enabling statement execution and state changes

19. Ruby MetaprogrammingImplementing attr_reader # Not really implemented this way class Module # add to system class def attr_reader(*syms) syms.each do |sym| class_eval%{def #{sym} @#{sym} end} end # syms.each end # attr_reader end # Module

20. Ruby MetaprogrammingImplementing attr_writer # Not really implemented this way class Module # add to system class def attr_writer(*syms) syms.each do |sym| class_eval %{def #{sym}=(val) @#{sym} = val end} end end # attr_writer end # Module

21. Ruby MetaprogrammingRuntime Callbacks class Employee # class definitions executable def Employee.inherited(sub) # class method puts "New subclass: #{sub}" # of Class end class Faculty < Employee end class Chair < Faculty end OUTPUTS New subclass: Faculty New subclass: Chair

22. Ruby MetaprogrammingRuntime Callbacks class Employee def method_missing(meth,*args) # instance method mstr = meth.to_s # of Object last = mstr[-1,1] base = mstr[0..-2] if last == "=" class_eval("attr_writer :#{base}") else class_eval("attr_reader :#{mstr}") end end end

23. Domain Specific Languages (DSL) • Programming or description language designed for particular family of problems • Specialized syntax and semantics • Alternative approaches • External language with specialized interpreter • Internal (embedded) language by tailoring a general purpose language

24. Martin Fowler DSL ExampleInput Data File #123456789012345678901234567890123456 SVCLFOWLER 10101MS0120050313 SVCLHOHPE 10201DX0320050315 SVCLTWO x10301MRP220050329 USGE10301TWO x50214..7050329

25. Martin Fowler DSL ExampleText Data Description mapping SVCL dsl.ServiceCall 4-18: CustomerName 19-23: CustomerID 24-27 : CallTypeCode 28-35 : DateOfCallString mapping USGE dsl.Usage 4-8 : CustomerID 9-22: CustomerName 30-30: Cycle 31-36: ReadDate

26. Martin Fowler DSL ExampleXML Data Description <ReaderConfiguration> <Mapping Code = "SVCL" TargetClass = "dsl.ServiceCall"> <Field name = "CustomerName" start = "4" end = "18"/> <Field name = "CustomerID" start = "19" end = "23"/> <Field name = "CallTypeCode" start = "24" end = "27"/> <Field name = "DateOfCallString" start = "28" end = "35"/> </Mapping> <Mapping Code = "USGE" TargetClass = "dsl.Usage"> <Field name = "CustomerID" start = "4" end = "8"/> <Field name = "CustomerName" start = "9" end = "22"/> <Field name = "Cycle" start = "30" end = "30"/> <Field name = "ReadDate" start = "31" end = "36"/> </Mapping> </ReaderConfiguration>

27. Martin Fowler DSL ExampleRuby Data Description mapping('SVCL', ServiceCall) do extract 4..18, 'customer_name' extract 19..23, 'customer_ID' extract 24..27, 'call_type_code' extract 28..35, 'date_of_call_string' end mapping('USGE', Usage) do extract 9..22, 'customer_name' extract 4..8, 'customer_ID' extract 30..30, 'cycle' extract 31..36, 'read_date‘ end

28. Martin Fowler DSL ExampleRuby DSL Class (1) require 'ReaderFramework' class BuilderRubyDSL def initialize(filename) @rb_dsl_file = filename end def configure(reader) @reader = reader rb_file = File.new(@rb_dsl_file) instance_eval(rb_file.read, @rb_dsl_file) rb_file.close end

29. Martin Fowler DSL ExampleRuby DSL Class (2 of 3) def mapping(code,target) @cur_mapping = ReaderFramework::ReaderStrategy.new( code,target) @reader.add_strategy(@cur_mapping) yield end def extract(range,field_name) begin_col = range.begin end_col = range.end end_col -= 1 if range.exclude_end? @cur_mapping.add_field_extractor( begin_col,end_col,field_name) end end#BuilderRubyDSL

30. Martin Fowler DSL ExampleRuby DSL Class (3 of 3) class ServiceCall; end class Usage; end class TestRubyDSL def TestRubyDSL.run rdr = ReaderFramework::Reader.new cfg = BuilderRubyDSL.new("dslinput.rb") cfg.configure(rdr) inp = File.new("fowlerdata.txt") res = rdr.process(inp) inp.close res.each {|o| puts o.inspect} end end

31. Using Blocks and Iterators Inverted Index (1) class InvertedIndex @@wp = /(\w+([-'.]\w+)*)/ DEFAULT_STOPS = {"the" => true, "a" => true, "an" => true} def initialize(*args) @files_indexed = [] @index = Hash.new @stops = Hash.new if args.size == 1 args[0].each {|w| @stops[w] = true} else @stops = DEFAULT_STOPS end end

32. Using Blocks and Iterators Inverted Index (2) def index_file(filename) unless @files_indexed.index(filename) == nil STDERR.puts("#{filename} already indexed.") return end unless File.exist? Filename STDERR.puts("#{filename} does not exist.") return end unless File.readable? Filename STDERR. puts("#{filename} is not readable.") return end @files_indexed << filename

33. Using Blocks and Iterators Inverted Index (3) inf = File.new(filename) lineno = 0 inf.each do |s| lineno += 1 words = s.scan(@@wp).map {|a| a[0].downcase} words = words.reject {|w| @stops[w]} words = words.map {|w| [w,[filename,[lineno]]]} words.each do |p| @index[p[0]] = [] unless @index.has_key? p[0] @index[p[0]] = @index[p[0]].push(p[1]) end end inf.close

34. Using Blocks and Iterators Inverted Index (4) @index.each do |k,v| # k => v is hash entry @index[k] = v.sort {|a,b| a[0] <=> b[0]} end @index.each do |k,v| @index[k] = v.slice(1...v.length).inject([v[0]]) do |acc, e| if acc[-1][0] == e[0] acc[-1][1] = acc[-1][1] + e[1] else acc = acc + [e] end acc end end#@index.each's block self end#index_file

35. Using Blocks and Iterators Inverted Index (5) def lookup(word) if @index[word] @index[word].map {|f| [f[0].clone, f[1].clone] } else nil end end # … end

36. Questions