cond 0.2.0

data/lib/cond/cond_private/defaults.rb

@@ -0,0 +1,78 @@
+
+require 'cond/cond_private/symbol_generator'
+require 'enumerator' if RUBY_VERSION <= "1.8.6"
+
+module Cond
+  module CondPrivate
+    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
+end

data/lib/cond/cond_private/symbol_generator.rb

@@ -0,0 +1,45 @@
+
+require 'thread'
+
+module Cond
+  module CondPrivate
+    module SymbolGenerator
+      @count = 'a'
+      @mutex = Mutex.new
+      @recycled = []
+      @object_id_to_sym_list = Hash.new
+      @finalizer = lambda { |id|
+        recycle(@object_id_to_sym_list.delete(id))
+      }
+
+      class << self
+        def gensym
+          @mutex.synchronize {
+            if @recycled.empty?
+              @count.succ!
+              :"|#{@count}"
+            else
+              @recycled.shift
+            end
+          }
+        end
+
+        def recycle(syms)
+          @mutex.synchronize {
+            @recycled.concat(syms)
+          }
+        end
+        
+        def track(object, syms)
+          @mutex.synchronize {
+            @object_id_to_sym_list[object.object_id] = syms.dup
+            ObjectSpace.define_finalizer(object, @finalizer)
+          }
+        end
+      end
+      
+      define_method :gensym, &method(:gensym)
+      private :gensym
+    end
+  end
+end

data/lib/cond/cond_private/thread_local.rb

@@ -0,0 +1,77 @@
+
+require 'thread'
+require 'cond/cond_private/symbol_generator'
+
+module Cond
+  module CondPrivate
+    #
+    # Thread-local variable.
+    #
+    class ThreadLocal
+      include SymbolGenerator
+
+      #
+      # If +value+ is called before +value=+ then the result of
+      # &default is used.
+      #
+      # &default normally creates a new object, otherwise the returned
+      # object will be shared across threads.
+      #
+      def initialize(&default)
+        @name = gensym
+        @accessed = gensym
+        @default = default
+        SymbolGenerator.track(self, [@name, @accessed])
+      end
+
+      #
+      # Reset to just-initialized state for all threads.
+      #
+      def clear(&default)
+        Thread.exclusive {
+          @default = default
+          Thread.list.each { |thread|
+            thread[@accessed] = nil
+            thread[@name] = nil
+          }
+        }
+      end
+      
+      def value
+        unless Thread.current[@accessed]
+          if @default
+            Thread.current[@name] = @default.call
+          end
+          Thread.current[@accessed] = true
+        end
+        Thread.current[@name]
+      end
+      
+      def value=(value)
+        Thread.current[@accessed] = true
+        Thread.current[@name] = value
+      end
+
+      class << self
+        def accessor_module(name, subclass = self, &block)
+          var = subclass.new(&block)
+          Module.new {
+            define_method(name) {
+              var.value
+            }
+            define_method("#{name}=") { |value|
+              var.value = value
+            }
+          }
+        end
+        
+        def reader_module(name, subclass = self, &block)
+          accessor_module(name, subclass, &block).instance_eval {
+            remove_method "#{name}="
+            self
+          }
+        end
+      end
+    end
+  end
+end

data/readmes/restarts.rb

@@ -0,0 +1,84 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+#
+# http://c2.com/cgi/wiki?LispRestartExample
+#
+
+require 'pp'
+require 'cond'
+include Cond
+
+class RestartableFetchError < RuntimeError
+end
+
+def read_new_value(what)
+  print("Enter a new #{what}: ")
+  eval($stdin.readline.chomp)
+end
+
+def restartable_fetch(hash, key, default = nil)
+  restartable do
+    restart :continue, "Return not having found the value." do
+      return default
+    end
+    restart :try_again, "Try getting the key from the hash again." do
+      again
+    end
+    restart :use_new_key, "Use a new key." do
+      key = read_new_value("key")
+      again
+    end
+    restart :use_new_hash, "Use a new hash." do
+      hash = read_new_value("hash")
+      again
+    end
+    hash.fetch(key) {
+      raise RestartableFetchError,
+        "Error getting #{key.inspect} from:\n#{hash.pretty_inspect}"
+    }
+  end
+end
+
+fruits_and_vegetables = Hash[*%w[
+   apple fruit
+   orange fruit
+   lettuce vegetable
+   tomato depends_on_who_you_ask
+]]
+
+Cond.with_default_handlers {
+  puts("value: " + restartable_fetch(fruits_and_vegetables, "mango").inspect)
+}
+
+#  % ruby readmes/restarts.rb
+#  readmes/restarts.rb:49:in `<main>'
+#  Error getting "mango" from:
+#  {"apple"=>"fruit",
+#   "orange"=>"fruit",
+#   "lettuce"=>"vegetable",
+#   "tomato"=>"depends_on_who_you_ask"}
+#  
+#    0: Return not having found the value. (:continue)
+#    1: Try getting the key from the hash again. (:try_again)
+#    2: Use a new hash. (:use_new_hash)
+#    3: Use a new key. (:use_new_key)
+#  Choose number: 3
+#  Enter a new key: "apple"
+#  value: "fruit"
+#  
+#  % ruby readmes/restarts.rb
+#  readmes/restarts.rb:49:in `<main>'
+#  Error getting "mango" from:
+#  {"apple"=>"fruit",
+#   "orange"=>"fruit",
+#   "lettuce"=>"vegetable",
+#   "tomato"=>"depends_on_who_you_ask"}
+#  
+#    0: Return not having found the value. (:continue)
+#    1: Try getting the key from the hash again. (:try_again)
+#    2: Use a new hash. (:use_new_hash)
+#    3: Use a new key. (:use_new_key)
+#  Choose number: 2
+#  Enter a new hash: { "mango" => "mangoish fruit" }
+#  value: "mangoish fruit"
+

data/readmes/seibel_pcl.rb

@@ -0,0 +1,129 @@
+$LOAD_PATH.unshift "#{File.dirname(__FILE__)}/../lib"
+
+# 
+# http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html
+# 
+
+#
+# Note:
+# This file is ruby-1.8.7+ only.  For 1.8.6, require 'enumerator' and
+# change input.each_line to input.to_enum(:each_line).
+#
+
+##########################################################
+# setup
+
+require 'cond'
+require 'time'
+include Cond
+
+class MalformedLogEntryError < StandardError
+end
+
+LOG_FILE = "log.txt"
+
+LOG_FILE_CONTENTS = <<EOS
+2007-01-12 05:20:03|event w
+2008-02-22 11:11:41|event x
+2008-09-04 15:30:43|event y
+I like pancakes
+2009-02-12 07:29:33|event z
+EOS
+
+File.open(LOG_FILE, "w") { |out|
+  out.print LOG_FILE_CONTENTS
+}
+
+END { File.unlink(LOG_FILE) }
+
+def parse_log_entry(text)
+  time, event = text.split("|")
+  if event
+    return Time.parse(time), event
+  else
+    raise MalformedLogEntryError
+  end
+end
+
+def find_all_logs
+  [LOG_FILE]
+end
+
+def analyze_log(log)
+  parse_log_file(log)
+end
+
+##########################################################
+# book examples
+#
+
+#
+# (defun parse-log-file (file)
+#   (with-open-file (in file :direction :input)
+#     (loop for text = (read-line in nil nil) while text
+#        for entry = (handler-case (parse-log-entry text)
+#                      (malformed-log-entry-error () nil))
+#        when entry collect it)))
+#
+def parse_log_file0(file)
+  File.open(file) { |input|
+    input.each_line.inject(Array.new) { |acc, text|
+      entry = handling do
+        handle MalformedLogEntryError do
+        end
+        parse_log_entry(text)
+      end
+      entry ? acc << entry : acc
+    }
+  }
+end
+
+parse_log_file0(LOG_FILE)
+
+# 
+# (defun parse-log-file (file)
+#   (with-open-file (in file :direction :input)
+#     (loop for text = (read-line in nil nil) while text
+#        for entry = (restart-case (parse-log-entry text)
+#                      (skip-log-entry () nil))
+#        when entry collect it)))
+# 
+def parse_log_file(file)
+  File.open(file) { |input|
+    input.each_line.inject(Array.new) { |acc, text|
+      entry = restartable do
+        restart :skip_log_entry do
+          leave
+        end
+        parse_log_entry(text)
+      end
+      entry ? acc << entry : acc
+    }
+  }
+end
+
+Cond.with_default_handlers {
+  parse_log_file(LOG_FILE)
+}
+
+# 
+# (defun log-analyzer ()
+#   (handler-bind ((malformed-log-entry-error
+#                   #'(lambda (c)
+#                       (invoke-restart 'skip-log-entry))))
+#     (dolist (log (find-all-logs))
+#       (analyze-log log))))
+# 
+def log_analyzer
+  handling do
+    handle MalformedLogEntryError do
+      invoke_restart :skip_log_entry
+    end
+    find_all_logs.each { |log|
+      analyze_log(log)
+    }
+  end
+end
+
+log_analyzer
+

data/spec/basic_spec.rb

@@ -0,0 +1,66 @@
+require File.dirname(__FILE__) + "/common"
+
+class ExampleError < RuntimeError
+end
+
+include Cond
+
+describe "basic handler/restart functionality" do
+  it "should work using the raw form" do
+    memo = []
+    handlers = {
+      ExampleError => lambda { |exception|
+        memo.push :handler
+        invoke_restart(:example_restart, :x, :y)
+      }
+    }
+    restarts = {
+      :example_restart => lambda { |*args|
+        memo.push :restart
+        memo.push args
+      }
+    }
+    f = lambda {
+      memo.push :f
+      Cond.with_restarts(restarts) {
+        memo.push :raise
+        raise ExampleError
+      }
+    }
+    memo.push :first
+    Cond.with_handlers(handlers) {
+      f.call
+    }
+    memo.push :last
+    
+    memo.should == [:first, :f, :raise, :handler, :restart, [:x, :y], :last]
+  end
+
+  it "should work using the shiny form" do
+    memo = []
+
+    f = lambda {
+      memo.push :f
+      restartable do
+        restart :example_restart do |*args|
+          memo.push :restart
+          memo.push args
+        end
+        memo.push :raise
+        raise ExampleError
+      end
+    }
+  
+    memo.push :first
+    handling do
+      handle ExampleError do
+        memo.push :handler
+        invoke_restart :example_restart, :x, :y
+      end
+      f.call
+    end
+    memo.push :last
+
+    memo.should == [:first, :f, :raise, :handler, :restart, [:x, :y], :last]
+  end
+end