dynamic_variable 0.0.0

data/.gitignore

@@ -0,0 +1 @@
+pkg/

data/README.md

@@ -0,0 +1,113 @@
+# 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](http://c2.com/cgi/wiki?DynamicScoping), [fluid-let](http://www.megasolutions.net/scheme/fluid-binding-25366.aspx), [SRFI 39 parameters](http://srfi.schemers.org/srfi-39/srfi-39.html), [cflow pointcuts](http://www.eclipse.org/aspectj/doc/released/progguide/semantics-pointcuts.html#d0e5410), even [Scala has its own DynamicVariable](http://www.scala-lang.org/api/current/scala/util/DynamicVariable.html).
+
+# 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
+
+# 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 == []

data/Rakefile

@@ -0,0 +1,15 @@
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "dynamic_variable"
+    gemspec.summary = "Provides dynamically scoped variables."
+    gemspec.description = "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."
+    gemspec.email = "wtaysom@gmail.com"
+    gemspec.homepage = "http://github.com/wtaysom/Ruby-DynamicVariable"
+    gemspec.authors = ["William Taysom"]
+  end
+  Jeweler::GemcutterTasks.new
+rescue LoadError
+  puts "Jeweler not available. Install it with: gem install jeweler"
+end
+  

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/doc/readme_code/01example_at_start.rb

@@ -0,0 +1,14 @@
+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

data/doc/readme_code/02example_with_debug.rb

@@ -0,0 +1,21 @@
+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

data/doc/readme_code/03simple_with.rb

@@ -0,0 +1,20 @@
+def simple_with(value)
+  old_value = $value
+  $value = value
+  yield
+ensure
+  $value = old_value
+end
+
+
+describe '#simple_with' do it 'should behave' do
+
+simple_with(3) do
+  simple_with(4) do
+    $value.should == 4
+  end
+  $value.should == 3
+end
+$value.should == nil
+
+end end

data/dynamic_variable.gemspec

@@ -0,0 +1,49 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run the gemspec command
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{dynamic_variable}
+  s.version = "0.0.0"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["William Taysom"]
+  s.date = %q{2010-09-09}
+  s.description = %q{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.}
+  s.email = %q{wtaysom@gmail.com}
+  s.extra_rdoc_files = [
+    "README.md"
+  ]
+  s.files = [
+    ".gitignore",
+     "README.md",
+     "Rakefile",
+     "VERSION",
+     "doc/readme_code/01example_at_start.rb",
+     "doc/readme_code/02example_with_debug.rb",
+     "doc/readme_code/03simple_with.rb",
+     "dynamic_variable.gemspec",
+     "lib/dynamic_variable.rb",
+     "spec/dynamic_variable_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/wtaysom/Ruby-DynamicVariable}
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.3.7}
+  s.summary = %q{Provides dynamically scoped variables.}
+  s.test_files = [
+    "spec/dynamic_variable_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+    else
+    end
+  else
+  end
+end
+

data/lib/dynamic_variable.rb

@@ -0,0 +1,176 @@
+class DynamicVariable
+  @@un = Object.new
+  
+  def initialize(*pairs, &block)
+    @bindings = []
+    if block_given?
+      with(*pairs, &block)
+    else
+      push_pairs(pairs) unless pairs.empty?
+    end
+  end
+  
+  def push(variable, value)
+    pair = [variable, value]
+    @bindings << pair
+    pair
+  end
+  
+  def pop(variable)
+    index = rindex(variable)
+    @bindings.slice!(index)[1] if index
+  end
+  
+  ##
+  # with {}
+  #   varible defaults to :value
+  #   value defaults to nil
+  #
+  # with(value) { block }
+  #   variable defaults to :value
+  #
+  # with(variable, value) { block }
+  #
+  # with(variable_1, value_1, ..., variable_n_1, value_n_1, value_n) { block }
+  #   variable_n defaults to :value
+  #
+  # with(variable_1, value_1, ..., variable_n, value_n) { block }
+  #
+  def with(*pairs)
+    pairs = [nil] if pairs.empty?
+    push_pairs(pairs)
+    begin
+      yield(self)
+    ensure
+      pop_pairs(pairs)
+    end
+  end
+  
+  def with_module
+    this = self
+    mod = Module.new
+    mod.send(:define_method, :with) do |*args, &block|
+      this.with(*args, &block)
+    end
+    mod
+  end
+  
+  def [](variable)
+    find_binding(variable)[1]
+  end
+  
+  def []=(variable, value)
+    find_binding(variable)[1] = value
+  end
+  
+  def method_missing(variable, *args)    
+    if args.empty?
+      value = self[variable]
+      instance_eval %Q{def #{variable}; self[:#{variable}] end}
+    else
+      writer = variable
+      unless args.size == 1 and writer.to_s =~ /(.*)=/
+        raise NoMethodError, "undefined method `#{writer}' for #{self.inspect}"
+      end
+      variable = $1.to_sym
+      self[variable] = args[0]
+      instance_eval %Q{def #{writer}(v); self[:#{variable}] = v end}
+    end
+    value
+  end
+  
+  def variables
+    variables = {}
+    @bindings.each{|variable, value| variables[variable] = value}
+    variables
+  end
+  
+  def variables=(variables)
+    variables.each{|variable, value| self[variable] = value}
+  end
+  
+  def bindings(variable = @@un)
+    if variable == @@un
+      @bindings.map{|pair| pair.clone}
+    else
+      @bindings.select{|var, value| var == variable}.map!{|var, value| value}
+    end
+  end
+  
+  def bindings=(bindings)
+    set_bindings(bindings)
+  end
+  
+  def set_bindings(variable, bindings = @@un)
+    if bindings == @@un
+      bindings = variable
+      @bindings = bindings.map do |pair|
+        unless pair.is_a? Array and pair.size == 2
+          raise ArgumentError,
+            "expected [variable, value] pair, got #{pair.inspect}"
+        end
+        pair.clone
+      end
+    else
+      unless bindings.is_a? Array
+        raise ArgumentError,
+          "expected bindings to be Array, got a #{bindings.class}"
+      end
+      index = 0
+      old_bindings = @bindings
+      @bindings = []
+      old_bindings.each do |var, value|
+        if var == variable
+          unless index < bindings.size
+            next
+          end
+          value = bindings[index]
+          index += 1
+        end
+        push(var, value)
+      end
+      while index < bindings.size
+        value = bindings[index]
+        push(variable, value)
+        index += 1
+      end
+    end
+    bindings
+  end
+  
+private
+  
+  def find_binding(variable)
+    index = rindex(variable)
+    unless index
+      raise ArgumentError, "unbound variable #{variable.inspect}"
+    end
+    @bindings[index]
+  end
+  
+  def rindex(variable)
+    @bindings.rindex{|pair| pair[0] == variable}
+  end
+  
+  def push_pairs(pairs)
+    pairs.insert(-2, :value) if pairs.size.odd?
+    each_pair(pairs) {|variable, value| push(variable, value)}
+  end
+  
+  def pop_pairs(pairs)
+    each_pair(pairs) {|variable, value| pop(variable)}
+  end
+  
+  def each_pair(array)
+    pair_ready = false
+    head = nil
+    array.each do |v|
+      if pair_ready
+        yield(head, v)
+      else
+        head = v
+      end
+      pair_ready = !pair_ready
+    end
+  end
+end

data/spec/dynamic_variable_spec.rb

@@ -0,0 +1,580 @@
+require 'dynamic_variable'
+  
+describe DynamicVariable do
+  subject { DynamicVariable.new }
+  
+  before do
+    extend subject.with_module
+  end
+  
+  ### Utilities ###
+  
+  def x_and_y_bindings
+    [[:x, 1], [:y, 2], [:y, 3], [:x, 4]]
+  end
+  
+  def set_x_any_y_bindings
+    subject.bindings = x_and_y_bindings
+  end
+  
+  def bindings_should_equal_x_and_y_bindings
+    subject.bindings.should == x_and_y_bindings
+  end
+  
+  def bindings_should_be_empty
+    subject.bindings.should == []
+  end
+  
+  def expect_should_raise_unbound_variable(&block)
+    expect do
+      block[]
+    end.should raise_error ArgumentError, "unbound variable :z"
+  end
+  
+  ### Examples ###
+  
+  example "typical usage" do
+    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
+  end
+  
+  example "reflection" do
+    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 == []
+  end
+  
+  describe '.new' do
+    context "when called" do
+      context "with no arguments" do        
+        it "should have no bindings" do
+          DynamicVariable.new.bindings.should == []
+        end
+      end
+      
+      context "with one argument" do
+        it "should bind :value to argument" do
+          DynamicVariable.new(:argument).bindings.should ==
+            [[:value, :argument]]
+        end
+      end
+      
+      context "with two arguments" do
+        it "should bind the first to the second" do
+          DynamicVariable.new(:first, :second).bindings.should ==
+            [[:first, :second]]
+        end
+      end
+      
+      context "with an odd number of arguments" do
+        it "should bind :value to the second to last" do
+          DynamicVariable.new(:first, :second, :last).bindings.should == 
+            [[:first, :second], [:value, :last]]
+        end
+      end
+      
+      context "with an even number of arguments" do
+        it "should bind variable, value pairs" do
+          DynamicVariable.new(:var1, :val1, :var2, :val2, :var3,
+            :val3).bindings.should ==
+              [[:var1, :val1], [:var2, :val2], [:var3, :val3]]
+        end
+      end
+      
+      context "with a block" do
+        it "should pass self to the block" do
+          dv_in_block = nil;
+          dv = DynamicVariable.new do |dv|
+            dv.should be_a(DynamicVariable)
+            dv.value.should == nil
+            dv_in_block = dv
+          end
+          dv.should == dv_in_block
+          expect do
+            dv.value
+          end.should raise_error(ArgumentError, "unbound variable :value")
+        end
+      end
+    end
+  end
+  
+  describe '#push' do
+    it "should return the binding pair" do
+      subject.push(:x, 1).should == [:x, 1]
+    end
+    
+    it "should add binding pairs" do
+      subject.push(:x, 1)
+      subject.push(:y, 2)
+      subject.push(:z, 3)
+      subject.push(:x, 4)
+      
+      subject.bindings.should == [[:x, 1], [:y, 2], [:z, 3], [:x, 4]]
+    end
+    
+    it "should allow a variable to be any object" do
+      subject.push(1337, 1)
+      subject.push(nil, 2)
+      subject.push("", 3)
+      subject.push([], 4)
+      
+      subject.bindings.should == [[1337, 1], [nil, 2], ["", 3], [[], 4]]
+    end
+  end
+  
+  describe '#pop' do
+    before { set_x_any_y_bindings }
+    
+    it "should return the value of the variable" do
+      subject.pop(:x).should == 4
+    end
+    
+    it "should remove last occurence of variable" do
+      subject.pop(:x)
+      subject.bindings.should == [[:x, 1], [:y, 2], [:y, 3]]
+      
+      subject.pop(:x)
+      subject.bindings.should == [[:y, 2], [:y, 3]]
+    end
+    
+    it "should remove last occurence leaving other variables in order" do
+      subject.pop(:y)
+      subject.bindings.should == [[:x, 1], [:y, 2], [:x, 4]]
+      
+      subject.pop(:y)
+      subject.bindings.should == [[:x, 1], [:x, 4]]
+    end
+    
+    context "when variable is not found" do
+      it "should return nil and do nothing" do
+        subject.pop(:z).should == nil
+        bindings_should_equal_x_and_y_bindings
+      end
+    end
+  end
+  
+  describe '#with' do
+    it "should make bindings and clean up when done" do
+      with(:key, :value) do
+        subject.bindings.should == [[:key, :value]]
+      end
+      bindings_should_be_empty
+    end
+    
+    it "should yield self to the block" do
+      with do |dv|
+        dv.should == subject
+      end
+    end
+    
+    it "should return the result of its block" do
+      with{:result}.should == :result
+    end
+    
+    it "should nest nicely" do
+      with(:value) do
+        subject.bindings.should == [[:value, :value]]
+        with(:second_value) do
+          subject.bindings.should == [[:value, :value], [:value, :second_value]]
+        end
+        subject.bindings.should == [[:value, :value]]
+      end
+      bindings_should_be_empty
+    end
+    
+    it "should be exception safe" do
+      expect do
+        with(:value) do
+          subject.bindings.should == [[:value, :value]]
+          raise
+        end
+      end.should raise_error
+      bindings_should_be_empty
+    end
+    
+    context "when called" do
+      context "with no arguments" do
+        it "should bind :value to nil" do
+          with do
+            subject.bindings.should == [[:value, nil]]
+          end
+        end
+      end
+      
+      context "with one argument" do
+        it "should bind :value to argument" do
+          with(:argument) do
+            subject.bindings.should == [[:value, :argument]]
+          end
+        end
+      end
+      
+      context "with two arguments" do
+        it "should bind the first to the second" do
+          with(:first, :second) do
+            subject.bindings.should == [[:first, :second]]
+          end
+        end
+      end
+      
+      context "with an odd number of arguments" do
+        it "should bind :value to the second to last" do
+          with(:first, :second, :last) do
+            subject.bindings.should == [[:first, :second], [:value, :last]]
+          end
+        end
+      end
+      
+      context "with an even number of arguments" do
+        it "should bind variable, value pairs" do
+          with(:var1, :val1, :var2, :val2, :var3, :val3) do
+            subject.bindings.should ==
+              [[:var1, :val1], [:var2, :val2], [:var3, :val3]]
+          end
+        end
+      end
+      
+      context "with a variable repeated more than once" do
+        it "should bind the variable twice and unbind when done" do
+          with(:var, 1, :var, 2) do
+            subject.bindings.should == [[:var, 1], [:var, 2]]
+          end
+          subject.bindings.should == []
+        end
+      end
+      
+      context "without a block" do
+        it "should raise \"no block given\"" do
+          expect do
+            subject.with(:key, :value)
+          end.should raise_error LocalJumpError, /no block given/
+          bindings_should_be_empty
+        end
+      end
+    end
+  end
+  
+  describe '#with_module' do
+    it "should return a Module with a #with method" do
+      mod = subject.with_module
+      mod.should be_a Module
+      methods = mod.instance_methods(false)
+      methods.map(&:to_sym).should == [:with]
+    end
+  end
+  
+  describe '#[]' do
+    before { set_x_any_y_bindings }
+    
+    it "should return the nearest binding for a variable" do
+      subject[:x].should == 4
+      subject[:y].should == 3
+    end
+    
+    context "when there is no binding" do
+      it "should raise \"unbound variable\"" do
+        expect_should_raise_unbound_variable do
+          subject[:z]
+        end
+      end
+    end
+  end
+  
+  describe '#[]=' do
+    before { set_x_any_y_bindings }
+    
+    it "should update nearest binding for a variable" do
+      subject[:x] = -1
+      subject[:y] = -2
+      
+      subject.bindings.should == [[:x, 1], [:y, 2], [:y, -2], [:x, -1]]
+    end
+    
+    it "should return the value" do
+      (subject[:x] = -1).should == -1
+    end
+    
+    context "when there is no binding" do
+      it "should raise \"unbound variable\"" do
+        expect_should_raise_unbound_variable do
+          subject[:z] = -2
+        end
+      end
+    end
+  end
+  
+  describe '#method_missing', " reader and writer generation" do
+    before { set_x_any_y_bindings }
+    
+    it "should initially have no variable readers or writers defined" do
+      subject.methods(false).should == []
+    end
+    
+    it "should generate variable readers as needed" do
+      subject.x.should == 4
+      subject.methods(false).map(&:to_sym).should == [:x]
+    end
+    
+    it "should generate variable writers as needed" do
+      (subject.x = 4).should == 4
+      subject.methods(false).map(&:to_sym).should == [:x=]
+    end
+    
+    context "when variable is unbound" do
+      it "should raise \"unbound variable\"" do
+        expect_should_raise_unbound_variable do
+          subject.z
+        end
+        
+        expect_should_raise_unbound_variable do
+          subject.z = 3
+        end
+      end
+      
+      it "should not generate readers or writers" do
+        expect do
+          subject.z
+          subject.z = 3
+        end.should raise_error
+        
+        subject.methods(false).should == []
+      end
+    end
+    
+    context "with to many arguments to be a writer" do
+      it "should raise NoMethodError" do
+        expect do
+          subject.too_many(1, 2)
+        end.should raise_error NoMethodError,
+          /undefined method `too_many' for/
+      end
+    end
+    
+    context "with one argument but method name does not end in \"=\"" do
+      it "should raise NoMethodError" do
+        expect do
+          subject.not_writer(1)
+        end.should raise_error NoMethodError,
+          /undefined method `not_writer' for/
+      end
+    end  
+  end
+  
+  describe '#variables' do
+    before { set_x_any_y_bindings }
+    
+    it "should return hash of all variables with their current bindings" do
+      subject.variables.should == {:x => 4, :y => 3}
+    end
+  end
+  
+  describe '#variables=' do
+    before { set_x_any_y_bindings }
+    
+    it "should update current bindings of variables" do
+      subject.variables = {:x => -1, :y => -2}
+      subject.bindings.should == [[:x, 1], [:y, 2], [:y, -2], [:x, -1]]
+    end
+    
+    it "should return the variables" do
+      variables = {:x => -1, :y => -2}
+      (subject.variables = variables).should be_equal variables
+    end
+    
+    it "should accept assoc array as argument" do
+      subject.variables = [[:x, -1], [:y, -2]]
+      subject.bindings.should == [[:x, 1], [:y, 2], [:y, -2], [:x, -1]]
+    end
+    
+    context "when some variables are not mentioned" do
+      it "should retain the old bindings" do
+        subject.variables = {:y => -2}
+        subject.bindings.should == [[:x, 1], [:y, 2], [:y, -2], [:x, 4]]
+      end
+    end
+    
+    context "when an unbound variable is mentioned" do
+      it "should raise \"unbound variable\"" do
+        expect_should_raise_unbound_variable do
+          subject.variables = {:z => -3}
+        end
+      end
+      
+      it "should NOT update atomically" do
+        expect_should_raise_unbound_variable do
+          subject.variables = [[:y, -2], [:z, -3]]
+        end
+        subject.y.should == -2
+      end
+    end    
+  end
+  
+  describe '#bindings' do
+    before { set_x_any_y_bindings }
+    
+    context "with no argument" do
+      it "should return an array of all variable bindings" do
+        bindings_should_equal_x_and_y_bindings
+      end
+      
+      it "should not be affected by changes to the returned array" do
+        bindings = subject.bindings
+        bindings[0][1] = -1
+        bindings_should_equal_x_and_y_bindings
+      end
+    end
+    
+    context "with variable as argument" do
+      it "should return array of all bindings for variable" do
+        subject.bindings(:x).should == [1, 4]
+        subject.bindings(:y).should == [2, 3]
+      end
+      
+      context "when an unbound variable is used" do
+        it "should return empty array" do
+          subject.bindings(:z).should == []
+        end
+      end
+    end
+  end
+  
+  shared_examples_for "bindings writer" do       
+    it "should update all bindings" do
+      subject.send(bindings_writer, x_and_y_bindings)
+      bindings_should_equal_x_and_y_bindings
+    end
+    
+    it "should return the argument" do
+      bindings = x_and_y_bindings
+      subject.send(bindings_writer, bindings).should be_equal bindings
+    end
+    
+    it "should use a copy of bindings" do
+      bindings = x_and_y_bindings
+      subject.send(bindings_writer, bindings)
+      bindings[0][1] = -9
+      bindings_should_equal_x_and_y_bindings
+    end
+    
+    context "when bindings does not respond to #map" do
+      it "should raise NoMethodError" do
+        expect do
+          subject.send(bindings_writer, :oops)
+        end.should raise_error NoMethodError
+        bindings_should_be_empty
+      end
+    end
+    
+    context "when a binding is not an Array" do
+      it "should raise ArgumentError" do
+        expect do
+          subject.send(bindings_writer, [66])
+        end.should raise_error ArgumentError,
+          /expected \[variable, value\] pair, got/
+        bindings_should_be_empty
+      end
+    end
+    
+    context "when a binding is of the wrong size" do
+      it "should raise ArgumentError" do
+        expect do
+          subject.send(bindings_writer, [[1, 2, 3]])
+        end.should raise_error ArgumentError,
+          /expected \[variable, value\] pair, got/
+        bindings_should_be_empty
+      end
+    end    
+  end
+  
+  describe '#bindings=' do
+    let(:bindings_writer) { :bindings= }
+    
+    it_should_behave_like "bindings writer"
+  end
+  
+  describe '#set_bindings' do
+    context "with one argument" do
+      let(:bindings_writer) { :set_bindings }
+      
+      it_should_behave_like "bindings writer"
+    end
+    
+    context "with two arguments" do
+      before { set_x_any_y_bindings }
+      
+      it "should replace existing bindings for variable" do
+        subject.set_bindings(:x, [-1, -2])
+        subject.bindings.should == [[:x, -1], [:y, 2], [:y, 3], [:x, -2]]
+      end
+      
+      it "should return the bindings array" do
+        bindings = [-1, -2]
+        subject.set_bindings(:x, bindings).should be_equal bindings
+      end
+      
+      context "when there are fewer new bindings than existing bindings" do
+        it "should delete bindings from the end" do
+          subject.set_bindings(:x, [-1])
+          subject.bindings.should == [[:x, -1], [:y, 2], [:y, 3]]
+        end
+      end
+      
+      context "when there are more new bindings than existing bindings" do
+        it "should add bindings to the end" do
+          subject.set_bindings(:x, [-1, -2, -3])
+          subject.bindings.should ==
+            [[:x, -1], [:y, 2], [:y, 3], [:x, -2], [:x, -3]]
+        end
+      end
+      
+      context "when argument is not an array" do
+        it "should raise ArgumentError" do
+          expect do
+            subject.set_bindings(:x, :not_this)
+          end.should raise_error ArgumentError,
+            "expected bindings to be Array, got a Symbol"
+        end
+      end   
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+name: dynamic_variable
+version: !ruby/object:Gem::Version 
+  hash: 31
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 0
+  version: 0.0.0
+platform: ruby
+authors: 
+- William Taysom
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-09-09 00:00:00 +08:00
+default_executable: 
+dependencies: []
+
+description: 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.
+email: wtaysom@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README.md
+files: 
+- .gitignore
+- README.md
+- Rakefile
+- VERSION
+- doc/readme_code/01example_at_start.rb
+- doc/readme_code/02example_with_debug.rb
+- doc/readme_code/03simple_with.rb
+- dynamic_variable.gemspec
+- lib/dynamic_variable.rb
+- spec/dynamic_variable_spec.rb
+has_rdoc: true
+homepage: http://github.com/wtaysom/Ruby-DynamicVariable
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Provides dynamically scoped variables.
+test_files: 
+- spec/dynamic_variable_spec.rb