Ruby 3

Cay S. Horstmann

Metaprogramming

• Meta = about itself

  (from Greek: μετά = "after", "beyond", "with", "adjacent", "self")

• Metadata = data about the data
• Metaprogramming = Writing programs that modify programs (maybe themselves)
• "I'd rather write a program that writes a program than write a program"

Preliminaries

• Code in class gets executed when the class is defined

  0> class Test
  1>  puts "Hello", self, self.class
  1> end
  Hello  # printed when the class is defined
  Test  # Inside the class definition, self is the class that is being defined
  Class  # It is an object of class Class

• Can add methods to individual objects

  x = "C++"
  define x.to_s  # Overrides String#to_s just for this object
    "Ruby-=1"
  end

  • Works for all classes except numbers, Boolean values, symbols

Method Missing

• Can intercept calls to undefined methods by implementing method_missing

  class Roman 
    def self.method_missing(name, *args)
      r = name.to_s
      r.gsub!("IV" , "IIII")
      r.gsub!("IX" , "VIIII")
      r.gsub!("XL" , "XXXX")
      r.gsub!("XC" , "LXXXX")
      return r.count("I" ) + r.count("V" ) * 5 + r.count("X" ) * 10 +    
        r.count("L" ) * 50 + r.count("C" ) * 100
    end
  end
  
  Roman.LXXIV  # 74

  • *args is the variable-length array of the arguments
• Useful whenever there is a large (potentially infinite) collection of methods
• Note that method_missing is attached to self (i.e. the Roman class)

  That way, we intercept static methods.

• Practical example: XMLBuilder

  xb.Hello("World!", "type" => "global")
  <Hello type="global">World!</Hello>

• Use with care—hard to debug

Creating New Classes

• Class.new creates a new class with no name
• Use Object.const_set to give it a name

  klass = Class.new  # Can't call it class—that's a keyword
  Object.const_set("City", klass)

• Let's try adding some fields

  klass.attr_accessor("name", "country")

  Rats—that's a private method.

• Workaround: Put that code in superclass

  class Base
    def self.make_fields(fields) 
      attr_accessor *fields // *fields turns the array into an argument list
    end
  end

• Extend that class

  klass = Class.new(Base) // Argument is superclass of new class
  klass.make_fields(["name", "country"])
  x = klass.new
  x.name = "Ho Chi Minh City"

Creating New Methods

• Use define_method to define a method in a class

  class Base
    def self.make_fields(fields) 
      attr_accessor *fields
      define_method(:initialize) { |*values| 
        fields.each_with_index { |f,i| 
          instance_variable_set("@"+f, values[i]) 
        }
      }
    end
  end

  • Object#instance_variable_set sets an arbitrary field
• This produces a constructor such as

  def initialize(name, country)
    @name = name
    @country = country
  end

Inheritance Callback

• Now we can write a function make_class(name, fields) that makes a basic class out of a list of fields.
• Application: Make classes and objects from CSV files

  name,country
  Ho Chi Minh City,Vietnam
  Washington,United States

• Almost like ActiveRecord, except that goes the other way around:

  class City < ActiveRecord::Base

• Want to be notified when someone inherits from us

  class CSVBase
    def self.inherited(klass)
      # Read first row of CSV file and add fields to klass 
    end
  end

But Wait, There's More

• Can turn functionality into a module that can be mixed into any class
  • Even those that have superclasses
• Can augment methods, e.g. add logging calls before and after each method call
• Can generate arbitrary code on the fly
• Maybe you'll come up with another idea that nobody had thought about before

Lab

• You work with a buddy
• One of you (the coder) codes, the other (the scribe) types up answers
• Switch roles each lab
• The scribe submits lab work to the Sakai site

Reading from a File

You'll need to know how to read data from a file in Ruby. It's simple. Just make a file City.csv as indicated in the lecture slides, run this code, and see what it does.

filename = "City.csv"
data = File.new(filename)
header = data.gets.chomp
fields = header.split(",")
data.each { |line| 
  puts line.chomp.split(",")
}
data.close

Step 1 - Method Missing

1. Write a class CSVRecord that can be used as follows:

   r = CSVRecord.new("City", 1)
   puts r.name # Prints Washington

   In the constructor, read the first line from the file with the given name and extension .CSV. Stash away the headers in an instance field. Then read the given record (or, for simplicity, just the first one) into another instance field.

   In method_missing, find out the matching field and return the corresponding value. (Remember not to define it on self in this case.)

   What is your code? 

2. How can you deal with assignments

   r.name = "Saigon"

   Hint: Just print out the method name in method_missing.

   You don't have to implement this—just tell me what will work.

Step 2 - XMLBuilder

1. Start irb. Run

   require "rubygems"
   require "builder"
   xb = Builder::XmlMarkup.new(:target => $stdout, :indent => 1)
   xb.Hello "World!"

   What output do you get?

2. What is Hello? A field? A method? A parameter? A variable? A class? Something else?
3. What is "World"? Don't say "a string"—we know that. How is it related to xb.Hello?
4. Try xb.fred("Wilma"). Clearly the designers of the XML Builder didn't know or care about Fred. How is this implemented?
5. Try

   xb.Hello "World!", "type" => "global", "state" => "happy"

   What do you get?

6. How is that implemented?
7. Now try

   xb.date {
     xb.year "2006"
     xb.month "01"
     xb.day "01"
   }

   What output do you get?

8. What is going on? What is the {...}? How does the date method process it?
9. Generate the following XML in Ruby (of course with a loop inside xb.values)

   <values>
    <value>1</value>
    <value>2</value>
    <value>3</value>
    <value>4</value>
    <value>5</value>
    <value>6</value>
    <value>7</value>
    <value>8</value>
    <value>9</value>
   </values>

Step 3 - Building Classes

1. Write a function make_class(name, fields) that makes a subclass of Base out of a list of fields. For example,

   make_class("City", ["name", "country"]) // Makes City class
   c = new City("Ho Chi Minh City", "Vietnam")

2. Add a to_s method to the class made by make_class that yields a string of the form Classname,field1=value1,field2=value2,.... Example:

   City,name=Ho Chi Minh City,country=Vietnam

3. Complete

   class CSVBase < Base
     def self.inherited(klass)
       # Read first row of CSV file and add fields to klass 
     end
   end

   To test it, make a file City.csv and run

   class City < CSVBase
   end
   c = City.new("Berlin", "Germany")

4. Add a method to CSVBase for reading an array of all objects of the class.