cond 0.2.1 → 0.3.0

data/lib/cond/code_section.rb

@@ -0,0 +1,51 @@
+
+module Cond
+  class CodeSection  #:nodoc:
+    include SymbolGenerator
+    
+    def initialize(with, &block)
+      @with = with
+      @block = block
+      @again_args = []
+      @leave, @again = gensym, gensym
+      SymbolGenerator.track(self, @leave, @again)
+    end
+
+    def again(*args)
+      @again_args = (
+        case args.size
+        when 0
+          []
+        when 1
+          args.first
+        else
+          args
+        end
+      )
+      throw @again
+    end
+
+    def leave(*args)
+      case args.size
+      when 0
+        throw @leave
+      when 1
+        throw @leave, args.first
+      else
+        throw @leave, args
+      end
+    end
+
+    def run
+      catch(@leave) {
+        while true
+          catch(@again) {
+            Cond.send(@with, Hash.new) {
+              throw @leave, @block.call(*@again_args)
+            }
+          }
+        end
+      }
+    end
+  end
+end

data/lib/cond/cond.rb

@@ -0,0 +1,159 @@
+
+# 
+# Resolve errors without unwinding the stack.
+# 
+module Cond
+  VERSION = "0.3.0"
+
+  class << self
+    include DSL
+    include Wrapping
+
+    #
+    # Register a set of handlers.  The given hash is merged with the
+    # set of current handlers.
+    #
+    # When the block exits, the previous set of handlers (if any) are
+    # restored.
+    #
+    def with_handlers(handlers)
+      # note: leave unfactored due to notable yield vs &block performance
+      handlers_stack.push(handlers_stack.last.merge(handlers))
+      begin
+        yield
+      ensure
+        handlers_stack.pop
+      end
+    end
+    
+    #
+    # Register a set of restarts.  The given hash is merged with the
+    # set of current restarts.
+    #
+    # When the block exits, the previous set of restarts (if any) are
+    # restored.
+    #
+    def with_restarts(restarts)
+      # note: leave unfactored due to notable yield vs &block performance
+      restarts_stack.push(restarts_stack.last.merge(restarts))
+      begin
+        yield
+      ensure
+        restarts_stack.pop
+      end
+    end
+      
+    #
+    # A default handler is provided which runs a simple
+    # choose-a-restart input loop when +raise+ is called.
+    #
+    def with_default_handlers
+      # note: leave unfactored due to notable yield vs &block performance
+      with_handlers(defaults.handlers) {
+        yield
+      }
+    end
+  
+    #
+    # The current set of restarts which have been registered.
+    #
+    def available_restarts
+      restarts_stack.last
+    end
+      
+    #
+    # Find the closest-matching handler for the given Exception.
+    #
+    def find_handler(target)  #:nodoc:
+      find_handler_from(handlers_stack.last, target)
+    end
+
+    def find_handler_from(handlers, target)  #:nodoc:
+      handlers.fetch(target) {
+        found = handlers.inject(Array.new) { |acc, (klass, func)|
+          index = target.ancestors.index(klass)
+          if index
+            acc << [index, func]
+          else
+            acc
+          end
+        }.sort_by { |t| t.first }.first
+        found and found[1]
+      }
+    end
+  
+    def run_code_section(klass, &block) #:nodoc:
+      section = klass.new(&block)
+      Cond.code_section_stack.push(section)
+      begin
+        section.instance_eval { run }
+      ensure
+        Cond.code_section_stack.pop
+      end
+    end
+
+    def check_context(keyword)  #:nodoc:
+      section = Cond.code_section_stack.last
+      case keyword
+      when :restart
+        unless section.is_a? RestartableSection
+          Cond.original_raise(
+            ContextError,
+            "`#{keyword}' called outside of `restartable' block"
+          )
+        end
+      when :handle
+        unless section.is_a? HandlingSection
+          Cond.original_raise(
+            ContextError,
+            "`#{keyword}' called outside of `handling' block"
+          )
+        end
+      when :leave, :again
+        unless section
+          Cond.original_raise(
+            ContextError,
+            "`#{keyword}' called outside of `handling' or `restartable' block"
+          )
+        end
+      end
+    end
+
+    ###############################################
+    # original raise
+    
+    define_method :original_raise, Kernel.instance_method(:raise)
+
+    ######################################################################
+    # data -- all data is per-thread and fetched from the singleton class
+    #
+    # Cond.defaults contains the default handlers.  To replace it,
+    # call
+    #
+    #   Cond.defaults.clear(&block)
+    #
+    # where &block creates a new instance of your class which
+    # implements the method 'handlers'.
+    #
+    # Note that &block should return a brand new instance.  Otherwise
+    # the returned object will be shared across threads.
+    #
+
+    stack_0  = lambda { Array.new }
+    stack_1  = lambda { Array.new.push(Hash.new) }
+    defaults = lambda { Defaults.new }
+    {
+      :code_section_stack => stack_0,
+      :exception_stack    => stack_0,
+      :handlers_stack     => stack_1,
+      :restarts_stack     => stack_1,
+      :defaults           => defaults,
+    }.each_pair { |name, create|
+      include ThreadLocal.reader_module(name, &create)
+    }
+
+    include ThreadLocal.accessor_module(:reraise_count) { 0 }
+  end
+end
+
+

data/lib/cond/defaults.rb

@@ -0,0 +1,73 @@
+
+module Cond
+  class Defaults
+    def initialize
+      @stream_in = STDIN
+      @stream_out = STDERR
+    end
+
+    attr_accessor :stream_in, :stream_out
+    
+    def handlers
+      {
+        Exception => method(:handler)
+      }
+    end
+
+    def handler(exception)
+      stream_out.puts exception.backtrace.last
+
+      if exception.respond_to? :message
+        stream_out.puts exception.message, ""
+      end
+        
+      #
+      # Show restarts in the order they appear on the stack (via
+      # partial differences).
+      #
+      # grr:
+      #
+      #   % ruby186 -ve 'p({:x => 33}.eql?({:x => 33}))'
+      #   ruby 1.8.6 (2009-03-10 patchlevel 362) [i686-darwin9.6.0]
+      #   false
+      #
+      #   % ruby187 -ve 'p({:x => 33}.eql?({:x => 33}))'
+      #   ruby 1.8.7 (2009-03-09 patchlevel 150) [i686-darwin9.6.0]
+      #   true
+      #
+      stack_arrays = Cond.restarts_stack.map { |level|
+        level.to_a.sort_by { |t| t.first.to_s }
+      }
+      restart_names = stack_arrays.to_enum(:each_with_index).map {
+        |level, index|
+        if index == 0
+          level
+        else
+          level - stack_arrays[index - 1]
+        end
+      }.map { |level| level.map { |t| t.first } }.flatten
+
+      restart_index = loop {
+        restart_names.each_with_index { |name, index|
+          func = Cond.available_restarts[name]
+          message = (
+            if func.respond_to?(:message) and func.message != ""
+              func.message + " "
+            else
+              ""
+            end
+          )
+          stream_out.printf("%3d: %s(%s)\n", index, message, name.inspect)
+        }
+        stream_out.print "Choose number: "
+        stream_out.flush
+        input = stream_in.readline.strip
+        if input =~ %r!\A\d+\Z! and
+            (0...restart_names.size).include?(input.to_i)
+          break input.to_i
+        end
+      }
+      Cond.invoke_restart(restart_names[restart_index])
+    end
+  end
+end

data/lib/cond/dsl.rb

@@ -0,0 +1,2 @@
+require 'cond'
+include Cond::DSL

data/lib/cond/dsl_definition.rb

@@ -0,0 +1,74 @@
+
+module Cond
+  module DSL
+    #
+    # Begin a handling block.  Inside this block, a matching handler
+    # gets called when +raise+ gets called.
+    #
+    def handling(&block)
+      Cond.run_code_section(HandlingSection, &block)
+    end
+
+    #
+    # Begin a restartable block.  A handler may transfer control to one
+    # of the restarts in this block.
+    #
+    def restartable(&block)
+      Cond.run_code_section(RestartableSection, &block)
+    end
+  
+    #
+    # Define a handler.
+    #
+    # The exception instance is passed to the block.
+    #
+    def handle(arg, message = "", &block)
+      Cond.check_context(:handle)
+      Cond.code_section_stack.last.handle(arg, message, &block)
+    end
+
+    #
+    # Define a restart.
+    #
+    # When a handler calls invoke_restart, it may pass additional
+    # arguments which are in turn passed to &block.
+    #
+    def restart(arg, message = "", &block)
+      Cond.check_context(:restart)
+      Cond.code_section_stack.last.restart(arg, message, &block)
+    end
+
+    #
+    # Leave the current handling or restartable block, optionally
+    # providing a value for the block.
+    #
+    # The semantics are the same as 'return'.  When given multiple
+    # arguments, it returns an array.  When given one argument, it
+    # returns only that argument (not an array).
+    #
+    def leave(*args)
+      Cond.check_context(:leave)
+      Cond.code_section_stack.last.leave(*args)
+    end
+
+    #
+    # Run the handling or restartable block again.
+    #
+    # Optionally pass arguments which are given to the block.
+    #
+    def again(*args)
+      Cond.check_context(:again)
+      Cond.code_section_stack.last.again(*args)
+    end
+
+    #
+    # Call a restart from a handler; optionally pass it some arguments.
+    #
+    def invoke_restart(name, *args, &block)
+      Cond.available_restarts.fetch(name) {
+        raise NoRestartError,
+        "Did not find `#{name.inspect}' in available restarts"
+      }.call(*args, &block)
+    end
+  end
+end

data/lib/cond/error.rb

@@ -0,0 +1,17 @@
+
+module Cond
+  class Error < RuntimeError
+  end
+
+  #
+  # Cond.invoke_restart was called with an unknown restart.
+  #
+  class NoRestartError < Error
+  end
+
+  #
+  # `handle', `restart', `leave', or `again' called out of context.
+  #
+  class ContextError < Error
+  end
+end

data/lib/cond/handler.rb

@@ -0,0 +1,10 @@
+
+module Cond
+  #
+  # A handler.  Use of this class is optional: you could pass lambdas
+  # to Cond.with_handlers, but you'll miss the description string
+  # shown by whichever tools might use it (currently none).
+  #
+  class Handler < MessageProc
+  end
+end

data/lib/cond/handling_section.rb

@@ -0,0 +1,12 @@
+
+module Cond
+  class HandlingSection < CodeSection  #:nodoc:
+    def initialize(&block)
+      super(:with_handlers, &block)
+    end
+    
+    def handle(sym, message, &block)
+      Cond.handlers_stack.last[sym] = Handler.new(message, &block)
+    end
+  end
+end

data/lib/cond/kernel_raise.rb

@@ -0,0 +1,59 @@
+
+module Kernel
+  remove_method :raise
+  def raise(*args)
+    if Cond.handlers_stack.last.empty?
+      # not using Cond
+      Cond.original_raise(*args)
+    else
+      last_exception, current_handler = Cond.exception_stack.last
+      exception = (
+        if last_exception and args.empty?
+          last_exception
+        else
+          begin
+            Cond.original_raise(*args)
+          rescue Exception => e
+            e
+          end
+        end
+      )
+      if current_handler
+        # inside a handler
+        handler = loop {
+          Cond.reraise_count += 1
+          handlers = Cond.handlers_stack[-1 - Cond.reraise_count]
+          if handlers.nil?
+            break nil
+          end
+          found = Cond.find_handler_from(handlers, exception.class)
+          if found and found != current_handler
+            break found
+          end
+        }
+        if handler
+          handler.call(exception)
+        else
+          Cond.reraise_count = 0
+          Cond.original_raise(exception)
+        end
+      else
+        # not inside a handler
+        Cond.reraise_count = 0
+        handler = Cond.find_handler(exception.class)
+        if handler
+          Cond.exception_stack.push([exception, handler])
+          begin
+            handler.call(exception)
+          ensure
+            Cond.exception_stack.pop
+          end
+        else
+          Cond.original_raise(exception)
+        end
+      end
+    end
+  end
+  remove_method :fail
+  alias_method :fail, :raise
+end