Introduction

Occasionally a method's behavior should depend on the context in which it is called. What is happening above me on the stack? DynamicVariable helps you in these context dependent situations.

DynamicVariable is similar to dynamic scope, fluid-let, SRFI 39 parameters, cflow pointcuts, even Scala has its own DynamicVariable.

Install

Nothing fancy:

> sudo gem install dynamic_variable

Example: Context Dependent Debugging

Suppose we have a method which is frequently_called. It works fine except when called from source_of_the_trouble. Suppose further that source_of_the_trouble doesn't directly invoke frequently_called instead there's a method in_the_middle. Our setup looks like this:

def source_of_the_trouble
in_the_middle
end
def in_the_middle
frequently_called
end
def frequently_called
puts "I'm called all the time."
end
1000.times { in_the_middle }
source_of_the_trouble

With DynamicVariable, we can easily change frequently_called so that it only brings up the debugger when called from source_of_the_trouble:

require 'rubygems'
require 'ruby-debug'
require 'dynamic_variable'
@troubled = DynamicVariable.new(false)
def source_of_the_trouble
@troubled.with(true) { in_the_middle }
end
def in_the_middle
frequently_called
end
def frequently_called debugger if @troubled.value
puts "I'm called all the time."
end
1000.times { in_the_middle }
source_of_the_trouble

Typical Usage

A DynamicVariable storing one :value and then :another:

DynamicVariable.new(1) do |dv|
dv.value.should == 1
dv.value = 2
dv.value.should == 2
dv.with(:another, :middle, 3) do
dv.another.should == :middle
dv.value.should == 3
dv.with(:another, :inner, 4) do
dv.another.should == :inner
dv.value.should == 4
end
dv.another.should == :middle
dv.value.should == 3
end
expect do
dv.another
end.should raise_error(ArgumentError, "unbound variable :another")
dv.value.should == 2
end

DynamicVariable::Mixin

The Mixin module adds a dynamic variable quality to any class:

class MixinExample
include DynamicVariable::Mixin
attr_accessor :x
def try
self.x = 4
x.should == 4
with(:x, 3) do
x.should == 3
self.x = 2
x.should == 2
with(:x, 1) do
x.should == 1
end
x.should == 2
end
x.should == 4
end
end
MixinExample.new.try

Why have a library?

Isn't it easy to set and reset a flag as the context changes? Sure, just watch out for raise, throw, and nesting:

def simple_with(value)
old_value = $value
$value = value
yield
ensure
$value = old_value
end

DynamicVariable adds the ability to reflect on your bindings. You can inspect them, and you can tinker with them if you feel the need:

dv = DynamicVariable.new(:v, 1, :w, 2) do |dv|
dv.with(:w, 3) do
dv.with(:v, 4) do
dv.bindings.should == [[:v, 1], [:w, 2], [:w, 3], [:v, 4]]
dv.bindings(:v).should == [1, 4]
dv.bindings(:w).should == [2, 3]
dv.set_bindings(:v, [-1, -2, -3])
dv.set_bindings(:w, [-4])
dv.bindings.should == [[:v, -1], [:w, -4], [:v, -2], [:v, -3]]
end
dv.bindings.should == [[:v, -1], [:w, -4], [:v, -2]]
end
dv.bindings.should == [[:v, -1], [:v, -2]]
end
dv.bindings.should == [[:v, -1]]
dv.bindings = []
dv.bindings.should == []