cond 0.2.0

data/spec/common.rb

@@ -0,0 +1,49 @@
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../lib"
+$LOAD_PATH.unshift File.dirname(__FILE__) + "/../support"
+
+# darn rspec warnings
+$VERBOSE = false
+begin
+  require 'spec'
+rescue LoadError
+  require 'rubygems'
+  require 'spec'
+end
+
+# NOTE: In jruby this must come after require 'rubygems'
+require 'cond'
+
+require 'pathname'
+require 'stringio'
+
+def pipe_to_ruby(code)
+  require 'quix/ruby'
+  IO.popen(%{"#{Quix::Ruby::EXECUTABLE}"}, "r+") { |pipe|
+    pipe.puts code
+    pipe.flush
+    pipe.close_write
+    pipe.read
+  }
+end
+
+def capture(input_string)
+  previous = [
+    $stdout, $stdin, Cond.defaults.stream_out, Cond.defaults.stream_in
+  ]
+  begin
+    StringIO.open("", "r+") { |output|
+      StringIO.open(input_string) { |input|
+        Cond.defaults.stream_out = output
+        Cond.defaults.stream_in = input
+        $stdout = output
+        $stdin = input
+        yield
+        output.rewind
+        output.read
+      }
+    }
+  ensure
+    $stdout, $stdin, Cond.defaults.stream_out, Cond.defaults.stream_in =
+      previous
+  end
+end

data/spec/error_spec.rb

@@ -0,0 +1,55 @@
+require File.dirname(__FILE__) + "/common"
+
+include Cond
+
+describe "error reporting" do
+  it "should raise NoRestartError when restart is not found" do
+    lambda {
+      invoke_restart(:zzz)
+    }.should raise_error(Cond::NoRestartError)
+  end
+
+  it "should raise ContextError when restart called outside " +
+    "restartable block" do
+    lambda {
+      restart :zzz do
+      end
+    }.should raise_error(Cond::ContextError)
+  end
+
+  it "should raise ContextError when restart called inside handling block" do
+    lambda {
+      handling do
+        restart :zzz do
+        end
+      end
+    }.should raise_error(Cond::ContextError)
+  end
+
+  it "should raise ContextError when handle called outside handling block" do
+    lambda {
+      handle RuntimeError do
+      end
+    }.should raise_error(Cond::ContextError)
+  end
+
+  it "should raise ContextError when restart called inside handling block" do
+    lambda {
+      handling do
+        restart :zzz do
+        end
+      end
+    }.should raise_error(Cond::ContextError)
+  end
+
+  [:leave, :again].each { |keyword|
+    desc =
+      "should raise ContextError when #{keyword} called outside " +
+      "restartable or handling block"
+    it desc do
+      lambda {
+        send keyword
+      }.should raise_error(Cond::ContextError)
+    end
+  }
+end

data/spec/leave_again_spec.rb

@@ -0,0 +1,88 @@
+require File.dirname(__FILE__) + "/common"
+
+include Cond
+
+[:handling, :restartable].each { |keyword|
+  describe "arguments to 'leave' have semantics of 'return'" do
+    it "should be passed to the #{keyword} block result (none)" do
+      send(keyword) do
+        leave
+      end.should == nil
+    end
+    it "should be passed to the #{keyword} block result (single)" do
+      send(keyword) do
+        leave 3
+      end.should == 3
+    end
+    it "should be passed to the #{keyword} block result (multiple)" do
+      send(keyword) do
+        leave 4, 5
+      end.should == [4, 5]
+    end
+    it "should be passed to the #{keyword} block result (single array)" do
+      send(keyword) do
+        leave([6, 7])
+      end.should == [6, 7]
+    end
+  end
+}
+
+[:handling, :restartable].each { |keyword|
+  describe "arguments to 'again' have semantics of 'return'" do
+    before :each do
+      @memo = []
+    end
+    it "should be passed to the #{keyword} block args (none)" do
+      send(keyword) do |*args|
+        @memo.push :visit
+        if @memo.size == 2
+          args.should == []
+          again
+        elsif @memo.size == 3
+          args.should == []
+          leave
+        end
+        again
+      end
+    end
+    it "should be passed to the #{keyword} block args (single)" do
+      send(keyword) do |*args|
+        @memo.push :visit
+        if @memo.size == 2
+          args.should == [3]
+          again
+        elsif @memo.size == 3
+          args.should == []
+          leave
+        end
+        again 3
+      end
+    end
+    it "should be passed to the #{keyword} block args (multiple)" do
+      send(keyword) do |*args|
+        @memo.push :visit
+        if @memo.size == 2
+          args.should == [4, 5]
+          again
+        elsif @memo.size == 3
+          args.should == []
+          leave
+        end
+        again 4, 5
+      end
+    end
+    it "should be passed to the #{keyword} block args (single array)" do
+      send(keyword) do |*args|
+        @memo.push :visit
+        if @memo.size == 2
+          args.should == [6, 7]
+          again
+        elsif @memo.size == 3
+          args.should == []
+          leave
+        end
+        again [6, 7]
+      end
+    end
+  end
+}

data/spec/matching_spec.rb

@@ -0,0 +1,86 @@
+require File.dirname(__FILE__) + "/common"
+
+class AnimalError < StandardError ; end
+class BirdError < AnimalError ; end
+class SparrowError < BirdError ; end
+class DogError < AnimalError ; end
+class RawError < Exception ; end
+
+RANDOM_ERRORS = [
+  Exception,
+  RuntimeError,
+  AnimalError,
+  BirdError,
+  SparrowError,
+  DogError,
+  RawError,
+]
+
+describe "handler matching system" do
+  before :all do
+    @memo = []
+    @handlers = RANDOM_ERRORS.inject(Hash.new) { |acc, ex|
+      acc.merge!(ex => lambda { |t| @memo.push ex })
+    }
+  end
+
+  it "should find an exact match when it is the only option" do
+    @memo.clear
+    Cond.with_handlers(DogError => @handlers[DogError]) {
+      raise DogError
+    }
+    @memo.should == [DogError]
+  end
+  
+  it "should find an exact match among other matches" do
+    @memo.clear
+    Cond.with_handlers(@handlers) {
+      raise DogError
+    }
+    @memo.should == [DogError]
+  end
+
+  it "should find a match given an Exception instance" do
+    @memo.clear
+    Cond.with_handlers(@handlers) {
+      raise DogError.new
+    }
+    @memo.should == [DogError]
+  end
+
+  it "should not find non-matches" do
+    lambda {
+      Cond.with_handlers(BirdError => lambda { |e| }) {
+        raise DogError
+      }
+    }.should raise_error(DogError)
+  end
+  
+  it "should find a related match" do
+    @memo.clear
+    Cond.with_handlers(BirdError => @handlers[BirdError]) {
+      raise SparrowError
+    }
+    @memo.should == [BirdError]
+  end
+
+  it "should find the closest related match" do
+    @memo.clear
+    handlers = {
+      BirdError => @handlers[BirdError],
+      AnimalError => @handlers[AnimalError],
+    }
+    Cond.with_handlers(handlers) {
+      raise SparrowError
+    }
+    @memo.should == [BirdError]
+  end
+
+  it "should work with the catch-all handler" do
+    @memo.clear
+    Cond.with_handlers(@handlers) {
+      raise SyntaxError
+    }
+    @memo.should == [Exception]
+  end
+end

data/spec/raise_spec.rb

@@ -0,0 +1,69 @@
+require File.dirname(__FILE__) + "/common"
+
+describe "raise replacement" do
+  it "should raise" do
+    lambda {
+      raise NameError
+    }.should raise_error(NameError)
+  end
+
+  it "should raise RuntimeError for 'raise \"string\"'" do
+    lambda {
+      raise "The mass of men lead lives of quiet desperation. --Thoreau"
+    }.should raise_error(RuntimeError)
+  end
+
+  it "should accept the three-argument form" do
+    begin
+      raise RuntimeError, "msg", ["zz"]
+    rescue => e
+      [e.class, e.message, e.backtrace].should == [RuntimeError, "msg", ["zz"]]
+    end
+  end
+
+  it "should raise TypeError if the third arg is not array of strings" do
+    ex = nil
+    begin
+      raise RuntimeError, "zz", Hash.new
+    rescue Exception => ex
+      ex = ex
+    end
+    ex.class.should == TypeError
+  end
+
+  it "should raise TypeError for random junk arguments" do
+    lambda {
+      raise "a", "b"
+    }.should raise_error(TypeError)
+    lambda {
+      raise 1, "b"
+    }.should raise_error(TypeError)
+    lambda {
+      raise RuntimeError, "msg", 33
+    }.should raise_error(TypeError)
+  end
+
+  it "should accept a non-Exception non-String which responds to #exception" do
+    klass = Class.new {
+      def exception
+        RuntimeError.new("my exception")
+      end
+    }
+    begin
+      raise klass.new
+    rescue => e
+      e.message.should == "my exception"
+    end
+  end
+
+  it "should raise TypeError if the argument is not a String, not " +
+    "an Exception, and does not respond to #exception" do
+    lambda {
+      raise 27
+    }.should raise_error(TypeError)
+  end
+
+  it "should be aliased to 'fail'" do
+    Kernel.instance_method(:raise).should == Kernel.instance_method(:fail)
+  end
+end

data/spec/reraise_spec.rb

@@ -0,0 +1,101 @@
+require File.dirname(__FILE__) + "/common"
+
+class ReraiseExampleError < Exception
+end
+
+include Cond
+
+describe "re-raise" do
+  it "should work work with no arguments" do
+    lambda {
+      handling do
+        handle ReraiseExampleError do
+          raise
+        end
+        raise ReraiseExampleError 
+      end
+    }.should raise_error(ReraiseExampleError)
+  end
+
+  describe "with arguments" do
+    before :all do
+      @memo = []
+      @func = lambda {
+        begin
+          handling do
+            handle ReraiseExampleError do
+              raise "---test"
+            end
+            raise ReraiseExampleError 
+          end
+        rescue Exception => e
+          @memo.push e
+          raise
+        end
+      }
+    end
+
+    it "should raise the new exception" do
+      @func.should raise_error(RuntimeError)
+    end
+
+    it "should preserve 'message'" do
+      @memo.first.message.should == "---test"
+    end
+  end
+
+  describe "nested" do
+    before :all do
+      @memo = []
+      @func = lambda {
+        handling do
+          handle ReraiseExampleError do
+            @memo.push :outer
+          end 
+          handling do
+            handle ReraiseExampleError do
+              @memo.push :inner
+              raise
+            end
+            raise ReraiseExampleError 
+          end
+        end
+      }
+    end
+
+    it "should transfer to handlers earlier in the stack" do
+      @func.should_not raise_error
+    end
+    
+    it "should be ordered inside to outside" do
+      @memo.should == [:inner, :outer]
+    end
+  end
+
+  describe "nested with empty inner blocks" do
+    before :all do
+      @memo = []
+      @func = lambda {
+        handling do
+          handle ReraiseExampleError do
+            @memo.push :outer
+            raise
+          end 
+          handling do
+            handling do
+              raise ReraiseExampleError
+            end
+          end
+        end
+      }
+    end
+
+    it "should transfer to handlers earlier in the stack" do
+      @func.should raise_error(ReraiseExampleError)
+    end
+    
+    it "should call the re-raising handler once" do
+      @memo.should == [:outer]
+    end
+  end
+end