A better way to call methods on an instance

Question

My question has a couple layers to it so please bear with me? I built a module that adds workflows from the Workflow gem to an instance, when you call a method on that instance. It has to be able to receive the description as a Hash or some basic data structure and then turn that into something that puts the described workflow onto the class, at run-time. So everything has to happen at run-time. It's a bit complex to explain what all the crazy requirements are for but it's still a good question, I hope. Anyways, The best I can do to be brief for a context, here, is this:

1. Build a class and include this module I built.
2. Create an instance of Your class.
3. Call the inject_workflow(some_workflow_description) method on the instance. It all must be dynamic.

The tricky part for me is that when I use public_send() or eval() or exec(), I still have to send some nested method calls and it seems like they use 2 different scopes, the class' and Workflow's (the gem). When someone uses the Workflow gem, they hand write these method calls in their class so it scopes everything correctly. The gem gets to have access to the class it creates methods on. The way I'm trying to do it, the user doesn't hand write the methods on the class, they get added to the class via the method shown here. So I wasn't able to get it to work using blocks because I have to do nested block calls e.g.

workflow() do # first method call
  # first nested method call.  can't access my scope from here
  state(:state_name) do 
    # second nested method call.  can't access my scope
    event(:event_name, transitions_to: :transition_to_state)
  end
end

One of the things I'm trying to do is call the Workflow#state() method n number of times, while nesting the Workflow#event(with, custom_params) 0..n times. The problem for me seems to be that I can't get the right scope when I nest the methods like that.

It works just like I'd like it to (I think...) but I'm not too sure I hit the best implementation. In fact, I think I'll probably get some strong words for what I've done. I tried using public_send() and every other thing I could find to avoid using class_eval() to no avail.

Whenever I attempted to use one of the "better" methods, I couldn't quite get the scope right and sometimes, I was invoking methods on the wrong object, altogether. So I think this is where I need the help, yeah?

This is what a few of the attempts were going for but this is more pseudo-code because I could never get this version or any like it to fly.

# Call this as soon as you can, after .new()
def inject_workflow(description)
  public_send :workflow do 
    description[:workflow][:states].each do |state|
      state.map do |name, event|
        public_send name.to_sym do # nested call occurs in Workflow gem
          # nested call occurs in Workflow gem
          public_send :event, event[:name], transitions_to: event[:transitions_to]
        end
      end
    end
  end
end

From what I was trying, all these kinds of attempts ended up in the same result, which was my scope isn't what I need because I'm evaluating code in the Workflow gem, not in the module or user's class.

Anyways, here's my implementation. I would really appreciate it if someone could point me in the right direction!

module WorkflowFactory
# ...
  def inject_workflow(description)       
      # Build up an array of strings that will be used to create exactly what 
      # you would hand-write in your class, if you wanted to use the gem.
      description_string_builder = ['include Workflow', 'workflow do']
      description[:workflow][:states].each do |state|
        state.map do |name, state_description|
          if state_description.nil? # if this is a final state...
            description_string_builder << "state :#{name}"
          else # because it is not a final state, add event information too.
            description_string_builder.concat([
              "state :#{name} do",
              "event :#{state_description[:event]}, transitions_to: :#{state_description[:transitions_to]}",
              "end"
            ])
          end
        end
      end
      description_string_builder << "end\n"
      begin
        # Use class_eval to run that workflow specification by 
        # passing it off to the workflow gem, just like you would when you use 
        # the gem normally.  I'm pretty sure this is where everyone's head pops...
        self.class.class_eval(description_string_builder.join("\n"))
        define_singleton_method(:has_workflow?) { true }
      rescue Exception => e
        define_singleton_method(:has_workflow?) { !!(puts e.backtrace) }
      end
    end 
  end
end


# This is the class in question.
class Job
  include WorkflowFactory
  # ... some interesting code for your class goes here
  def next!
    current_state.events.#somehow choose the correct event
  end
end

# and in some other place where you want your "job" to be able to use a workflow, you have something like this...
job = Job.new
job.done?
# => false
until job.done? do job.next! end
# progresses through the workflow and manages its own state awareness

I started this question off under 300000 lines of text, I swear. Thanks for hanging in there! Here's even more documentation, if you're not asleep yet. module in my gem

---