How can I convert this code to meta-programming, so I can stop duplicating it?

Question

I've got a small but growing framework for building .net systems with ruby / rake , that I've been working on for a while now. In this code base, I have the following:

require 'rake/tasklib'

def assemblyinfo(name=:assemblyinfo, *args, &block)
  Albacore::AssemblyInfoTask.new(name, *args, &block)
end

module Albacore
  class AssemblyInfoTask < Albacore::AlbacoreTask
    def execute(name)
      asm = AssemblyInfo.new
      asm.load_config_by_task_name(name)
      call_task_block(asm)
      asm.write
      fail if asm.failed
    end
  end
end

the pattern that this code follows is repeated about 20 times in the framework. The difference in each version is the name of the class being created/called (instead of AssemblyInfoTask, it may be MSBuildTask or NUnitTask), and the contents of the execute method. Each task has it's own execute method implementation.

I'm constantly fixing bugs in this pattern of code and I have to repeat the fix 20 times, every time I need a fix.

I know it's possible to do some meta-programming magic and wire up this code for each of my tasks from a single location... but I'm having a really hard time getting it to work.

my idea is that I want to be able to call something like this:

create_task :assemblyinfo do |name|
  asm = AssemblyInfo.new
  asm.load_config_by_task_name(name)
  call_task_block(asm)
  asm.write
  fail if asm.failed
end

and this would wire up everything I need.

I need help! tips, suggestions, someone willing to tackle this... how can I keep from having to repeat this pattern of code over and over?

Update: You can get the full source code here: http://github.com/derickbailey/Albacore/ the provided code is /lib/rake/assemblyinfotask.rb

Answer 1

Ok, here's some metaprogramming that will do what you want (in ruby18 or ruby19)

def create_task(taskname, &execute_body)
  taskclass = :"#{taskname}Task"
  taskmethod = taskname.to_s.downcase.to_sym
  # open up the metaclass for main
  (class << self; self; end).class_eval do
    # can't pass a default to a block parameter in ruby18
    define_method(taskmethod) do |*args, &block|
      # set default name if none given
      args << taskmethod if args.empty?
      Albacore.const_get(taskclass).new(*args, &block)
    end
  end
  Albacore.const_set(taskclass, Class.new(Albacore::AlbacoreTask) do
    define_method(:execute, &execute_body)
  end)
end

create_task :AssemblyInfo do |name|
  asm = AssemblyInfo.new
  asm.load_config_by_task_name(name)
  call_task_block(asm)
  asm.write
  fail if asm.failed
end

The key tools in the metaprogrammers tool box are:

• class<<self;self;end - to get at the metaclass for any object, so you can define methods on that object
• define_method - so you can define methods using current local variables

Also useful are

• const_set, const_get: allow you to set/get constants
• class_eval : allows you to define methods using def as if you were in a class <Classname> ... end region