mulligan 0.4.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 93a82e010fe6e85e2d4258e582448f6eba71aca0
+  data.tar.gz: e93698220f48079b7ed8a34889744fb84de4f657
+SHA512:
+  metadata.gz: 68fa8ce73ecec03457111bd4acc355b260e7fb5faccff1bb1a9195a9b62d2c761dce7406e53f3078cdf0fd94dae20829a98b90e3074017b1661331ac9cacf801
+  data.tar.gz: 172b8934dfdca12793f9931833d10d4a53aac6a831183150926ad591d7e9fbbe0261804692b25cc557a21d2948b36b485a23c07e1a4f03606c1d40a7ab54b319

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.travis.yml

@@ -0,0 +1,6 @@
+language: ruby
+rvm:
+  - 1.9.3-p484
+  - 2.0.0
+  - 2.1.0
+  - 2.1.1

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in mulligan.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2014 michaeljbishop
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,249 @@
+[![Build Status](https://travis-ci.org/michaeljbishop/mulligan.png?branch=master)](https://travis-ci.org/michaeljbishop/mulligan)
+# Mulligan
+
+"In golf,...a stroke that is replayed from the spot of the previous stroke without penalty, due to an errant shot made on the previous stroke. The result is, as the hole is played and scored, as if the first errant shot had never been made." -- [Wikipedia](http://en.wikipedia.org/wiki/Mulligan_(games)#Mulligan_in_golf)
+
+## Usage
+
+When rescuing an exception, the Mulligan gem allows you to execute some recovery code, then continue your program as if the exception had never been thrown in the first place
+
+Here's a very simple contrived example:
+```ruby
+ 1 require 'mulligan'
+ 2 
+ 3 def method_that_raises
+ 4   puts "RAISING"
+ 5   raise "You can ignore this" do |e|
+ 6     e.set_recovery :ignore do
+ 7       puts "IGNORING"
+ 8     end
+ 9   end
+10   puts "AFTER RAISE"
+11 end
+12
+13 def calling_method
+14   method_that_raises
+15   "SUCCESS"
+16   rescue Exception => e
+17     puts "RESCUED"
+18     e.recover :ignore
+19     puts "HANDLED"
+20 end
+```
+
+Running this at the REPL shows:
+
+```
+2.0.0-p353 :009 > calling_method
+RAISING
+RESCUED
+IGNORING
+AFTER RAISE
+ => "SUCCESS" 
+```
+
+### Yeah... wait, shouldn't we see "HANDLED" in that output?!
+
+Here's what happened in detail:
+
+1. `#method_that_raises` is called from `#calling_method` (line 14)
+2. `#method_that_raises` raises an exception *but* before it is raised, a "recovery" can be added to the exception (line 6) in the block passed to `#raise`. (The exception is the parameter 'e' passed to the `#raise` block)
+3. The exception is then raised (line 5) and rescued (line 16)
+4. The "recovery" on the exception is called (line 18) which executes the statement in the recovery block (defined on line 7).
+5. Since the exception has recovered, control taks us back to the point *immediately after the block passed to* `#raise` (line 10), continuing as if `#raise` hadn't been called in the first place.
+6. The method exits (line 11) and we return to line 15 as if we never saw the exception.
+7. We exit the method because there's no exception to rescue (line 20). The last value in the function was "SUCCESS" so that is returned.
+
+### I see what you did there. That's cool, but why should I care?
+
+You should care because your `rescue` statement is likely to be far from the `raise` in your program's execution and the further away it is, the harder it is to fix the error intelligently. It's even harder if that `raise` comes from a library you are calling.
+
+Specifying recoveries on the exception allows the lower-level code to offer strategies for fixing the exception without the higher-level code needing to know the internals of those strategies.
+
+Better yet, it offers the ability to "go back in time" [Groundhog Day](http://en.wikipedia.org/wiki/Groundhog_Day_(film))-style, but this time, your code knows how to play the piano, how to sculpt ice, and how to speak French.
+
+Find your favorite chair and read these:
+
+- [Dylan Reference Manual - Conditions - Background](http://opendylan.org/books/drm/Conditions_Background)
+- [Beyond Exception Handling: Conditions and Restarts](http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html) (keep in mind the "restarts" are what we are calling "recoveries").
+
+### This *seems* like a good thing, but what can I do with it?
+
+Here are some use cases:
+
+#### Fixing network connection errors
+
+```ruby
+def http_post(url, data)
+  ... networking code...
+  raise CredentialsExpiredException if response == 401
+  raise ConnectionFailedException if response == 404
+end
+
+def post_resource(object)
+  ... assemble url and data...
+  http_post(url, data)
+  rescue Exception => e
+    raise(e){|e|e.set_recovery(:retry){}}
+    retry if last_recovery == :retry
+end
+
+def save_resources
+  post_resource(user)
+  post_resource(post)
+  post_resource(comment)
+
+  rescue CredentialsExpiredException => e
+    ... fix credentials...
+    e.recover :retry
+  rescue ConnectionFailedException => e
+    ... switch from wifi to cellular...
+    e.recover :retry
+end
+```
+
+#### Screen Scraping (in Dylan)
+
+[The maling list post](https://groups.google.com/d/msg/comp.lang.dylan/gszO7d7BAok/zqVbQlNDKzAJ)
+
+This is going to be inherently messy and for a long-running program like this, potentially painful to restart if the data is found to be incorrect. Much better to just put in some recoveries and choose from them if errors are found.
+
+#### Handling errors in parsers
+
+You might write a parser to read XML or a log file format and it might encounter malformed entries. You can make that low-level parser code much more reusable if you specify a few recoveries in the raised exceptions. Higher level code will have many more choices to handle errors.
+
+BTW, Here's your second chance to read [Beyond Exception Handling: Conditions and Restarts](http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html). There's a log file parsing example in there.
+
+#### Ask your friendly Lisp coder. They've been solving these problems for years.
+
+You've always known he (or she) knew Lisp and now you have something to ask him about.
+
+## Some Notes About the Ruby Implementation
+### Methods
+#### Kernel#raise
+1. `Kernel#raise` now has a return value! It is the value returned from the recovery block.
+2. `Kernel#raise` also yields the exception to a block. It does this since it's pretty common to have `Kernel#raise` create an exception for you and without this, you couldn't otherwise attach recoveries.
+
+```ruby
+def test
+  # (result is explicit for this example)
+  result = raise "Test" do |e|              # yields Exception to the block
+    e.set_recovery(:test_return){"hello"}   # recovery block returns a string
+  end
+  result
+rescue Exception => e
+  e.recover :test_return
+end
+```
+
+returns 
+
+```
+2.0.0-p353 :012 > test
+ => "hello" 
+```
+
+#### You can pass parameters to Exception#recover
+The first parameter is always the id of the recovery. The rest will be passed directly to the recovery block. Building on the above example:
+
+```ruby
+def test
+  # (result is explicit for this example)
+  result = raise "Test" do |e|
+    e.set_recovery(:test_return){|p|p} # pass back whatever is passed in
+  end
+  result
+rescue Exception => e
+  e.recover :test_return, 5
+end
+```
+
+returns 
+
+```
+2.0.0-p353 :012 > test
+ => 5
+```
+
+#### Your recovery can attach data to be read by the rescue clause
+You can pass an options hash to the `rescue` clause that is attached to your recovery. This is handy if you want to attach extra data about the recovery or the circumstances in which it is being raised. Pass them as the second parameter in `Exception#set_recovery`. You can retrieve them with `Exception#recovery_options`. Reserved keys are `:summary`, and `:discussion`
+```ruby
+raise "Test" do |e|
+  summary = "Replaces the misparsed entry with one you specify."
+  e.set_recovery(:replace_value, :summary => summary){|p|p}
+end
+```
+
+To demonstrate this, here's a rescue statement. The rescue simply prints out the description which is not really useful as a rescue statement, but it's an example of how a REPL might output to the user a list of recoveries to choose from and the details of what they do.
+
+```ruby
+rescue MisparsedEntryException => e
+  $stderr.puts "Choose a recovery:"
+  e.recovery_identifiers.each do |id|
+    $stderr.puts "  #{id}: - #{e.recovery_options(id)[:summary]}"
+  end
+  ... read choice and execute ...
+```
+
+#### Kernel#last_recovery
+There is a new method: `Kernel#last_recovery` which will return the id of the last recovery invoked for the current thread. So you can do things like this:
+
+```ruby
+begin
+  ... some code ...
+rescue Exception => e
+  raise(e){|e|e.set_recovery(:retry){}}
+  retry if last_recovery == :retry
+end
+```
+
+### Mulliigan uses #callcc
+
+There is more than one way to do this. In the end, I wanted something that would fit very naturally into Ruby's existing Exception mechanism, yet offer as much of the benefits of Lisp's "restart" as I could.
+
+However, to make that happen, I had to use the `#callcc` method. I'm not completely sure how supported this is across different Ruby implementations. Additionally, I've read that it can be a rather slow method. It's important to note that if an exception is raised but does not have any attached recoveries, `#callcc` will not be called and the standard exception mechanism is used.
+
+### Ruby Support
+
+[![Build Status](https://travis-ci.org/michaeljbishop/mulligan.png?branch=master)](https://travis-ci.org/michaeljbishop/mulligan)
+ Mulligan supports MRI versions 1.9.3 -> 2.1.1
+
+### "Recovery"? What's wrong with "Restart"?
+
+I had to make a hard choice about naming the thing that allows an exception to be recovered from. "Restart" is the word used in Lisp, but because it is used as a verb and as a noun, it makes it hard to know what a Ruby method named `#restart` would do. Does it return a "restart" or does it execute a restart?
+
+Changing the name to a noun subtracts that confusion (though arguably adds some back for those coming from languages where the "restart" name is entrenched).
+
+## Influences
+- [Beyond Exception Handling: Conditions and Restarts](http://www.gigamonkeys.com/book/beyond-exception-handling-conditions-and-restarts.html) -- (from [Practical Common Lisp](http://www.gigamonkeys.com/book/))
+- [Things You Didn't Know About Exceptions](http://avdi.org/talks/rockymtnruby-2011/things-you-didnt-know-about-exceptions.html) (Avdi Grimm)
+- [Restartable Exceptions](http://chneukirchen.org/blog/archive/2005/03/restartable-exceptions.html) (Christian Neukirchen)
+- [Common Lisp conditions](https://www.ruby-forum.com/topic/179474) (Ruby Forum)
+
+### Acknowledgements
+Thanks to [Ryan Angilly](https://twitter.com/angilly) of [Ramen](https://ramen.is) who graciously released the gem name 'mulligan' to be used with this project. If you've got a good software project, consider launching with them.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'mulligan'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install mulligan
+
+## Contributing
+
+1. Fork it [http://github.com/michaeljbishop/mulligan](http://github.com/michaeljbishop/mulligan)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request
+
+## Homepage
+
+[http://michaeljbishop.github.io/mulligan/](http://michaeljbishop.github.io/mulligan/)

data/Rakefile

@@ -0,0 +1,12 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+require "rake/extensiontask"
+
+Rake::ExtensionTask.new "mulligan" do |ext|
+  ext.lib_dir = "lib/mulligan"
+end
+
+RSpec::Core::RakeTask.new(:spec => :compile)
+
+task :default => :spec

data/ext/mulligan/extconf.rb

@@ -0,0 +1,3 @@
+require "mkmf"
+
+create_makefile "mulligan/mulligan"

data/ext/mulligan/mulligan.c

@@ -0,0 +1,203 @@
+#include <ruby.h>
+
+
+// -----------------------------------------------------------
+//  UTILITIES
+// -----------------------------------------------------------
+
+#define ARRAY_SIZE(var) (sizeof(var)/sizeof(var[0]))
+
+// -----------------------------------------------------------
+//  DECLARATIONS
+// -----------------------------------------------------------
+
+static VALUE rb_mulligan_raise(int argc, VALUE *argv, VALUE self);
+static VALUE callcc_block(VALUE c, VALUE in_context, int argc, VALUE argv[]);
+static VALUE __set_continuation__block(VALUE unused, VALUE in_context, int argc, VALUE argv[]);
+
+static ID id_recoveries = 0;
+static ID id_empty_ = 0;
+static ID id_send = 0;
+static ID id_callcc = 0;
+static ID id_call = 0;
+static ID id___set_continuation__ = 0;
+static ID id_puts = 0;
+
+// ===========================================================
+//  MAIN ENTRY POINT
+// ===========================================================
+
+void Init_mulligan(void)
+{
+  VALUE mMulligan = rb_define_module("Mulligan");
+  VALUE mKernel = rb_define_module_under(mMulligan, "Kernel");
+  rb_define_method(mKernel, "raise", rb_mulligan_raise, -1);
+  rb_define_method(mKernel, "fail", rb_mulligan_raise, -1);
+
+#if RUBY_API_VERSION_MAJOR < 2
+  // completely replaces Ruby's version of raise.
+  // In Ruby 2 we prepend (but don't call super)
+  rb_define_global_function("raise", rb_mulligan_raise, -1);
+  rb_define_global_function("fail", rb_mulligan_raise, -1);
+#endif
+
+  rb_require("continuation");
+  id_recoveries = rb_intern("recoveries");
+  id_empty_ = rb_intern("empty?");
+  id_send = rb_intern("send");
+  id_callcc = rb_intern("callcc");
+  id_call = rb_intern("call");
+  id___set_continuation__ = rb_intern("__set_continuation__");
+  id_puts = rb_intern("puts");
+}
+
+
+/* -----------------------------------------------------------
+//  Here is the template ruby code that we are approximating
+//  in C. Native-only calls are surround by <<>>
+// -----------------------------------------------------------
+def raise(*args)
+  e = <<make_exception(*args)>>
+  yield e if block_given?
+
+  # only use callcc if there are restarts otherwise re-raise it
+  <<rb_exc_raise(e)>> if e.send(:recoveries).empty?
+  should_raise = true
+  result = callcc do |c|
+    e.send(:__set_continuation__) do |*args,&block|
+      should_raise = false
+      c.call(*args,&block)
+    end
+  end
+  <<rb_exc_raise(e)>> if should_raise
+  result
+end
+// -----------------------------------------------------------
+// There is one big difference which is at all costs, we only
+// call `rb_exc_raise` from the current frame. This is important
+// because we want the stack-trace and current stack-frame to
+// be identical to what they were if we just called the standard
+// #raise method. If we call `rb_exc_raise` within a block or
+// call super, we will lose that stack-frame context.
+// For this reason, you'll see that awkward `should_raise` variable
+// in the source above.
+// -----------------------------------------------------------*/
+
+
+static VALUE
+rb_mulligan_raise(int argc, VALUE *argv, VALUE self)
+{
+    // -----------------------------------------------------------
+    //  C90-compliance asks us to declare all variables at the top
+    // -----------------------------------------------------------
+    VALUE recoveries = Qnil;
+    VALUE should_raise_ary = Qnil;
+    VALUE contextVars[3];
+    VALUE context = Qnil;
+    VALUE result = Qnil;
+    VALUE is_empty = Qnil;
+
+    // -----------------------------------------------------------
+    //  Get a reference to the Exception object
+    // -----------------------------------------------------------
+    VALUE e = rb_make_exception(argc, argv);
+
+    if (NIL_P(e)) {
+      // get whatever is in $!. I'm sure this is slow
+      e = rb_eval_string("$!");
+      // what I'd like to use reallu like to use
+//       e = rb_rubylevel_errinfo(); // internal ruby call, yet necessary
+    }
+
+    if (NIL_P(e)) {
+      e = rb_exc_new(rb_eRuntimeError, 0, 0);
+    }
+
+    // -----------------------------------------------------------
+    //  With the Exception in place, yield to the block
+    // -----------------------------------------------------------
+    if (rb_block_given_p())
+      rb_yield(e);
+
+    // -----------------------------------------------------------
+    //  If there are no recoveries, just throw it without a callcc
+    // -----------------------------------------------------------
+    recoveries = rb_funcall(e, id_send, 1, ID2SYM(id_recoveries));
+    is_empty = rb_funcall(recoveries, id_empty_, 0);
+    if (RTEST(is_empty))
+        goto raise;
+    
+    // -----------------------------------------------------------
+    //  There are recoveries so we first capture the continuation
+    //  using callcc
+    // -----------------------------------------------------------
+
+    // A note about should_raise_ary:
+    // 2 callbacks from now (in `__set_continuation__block`) we are
+    // going to want to change the value of this from true to false. Since Qtrue
+    // is not a pointer, we are going to make a ghetto-pointer by putting it in
+    // an array of one. That array will be passed to the callback where it will be
+    // modified and we can read it still in this context after all the callbacks
+    // are complete.
+    should_raise_ary = rb_ary_to_ary(Qtrue);
+    contextVars[0] = self;
+    contextVars[1] = should_raise_ary;
+    contextVars[2] = e;
+    context = rb_ary_new4(ARRAY_SIZE(contextVars), contextVars);
+    
+    result = rb_block_call(
+        self,
+        id_callcc,
+        0, // argc
+        0, // argv
+        RUBY_METHOD_FUNC(callcc_block),
+        context
+        );
+
+    // Here we read our "pointer"
+    if (!RTEST(rb_ary_entry(should_raise_ary, 0)))
+      return result;
+
+raise:
+    rb_exc_raise(e);
+//     UNREACHABLE;
+}
+
+static VALUE
+callcc_block(VALUE c, VALUE in_context, int argc, VALUE argv[])
+{
+    VALUE self =             rb_ary_entry(in_context, 0);
+    VALUE should_raise_ary = rb_ary_entry(in_context, 1);
+    VALUE e =                rb_ary_entry(in_context, 2);
+
+    VALUE contextVars[] = {self, should_raise_ary, c};
+    VALUE context = rb_ary_new4(ARRAY_SIZE(contextVars), contextVars);
+
+    return rb_block_call(
+        e,
+        id___set_continuation__,
+        0, // argc
+        0, // argv
+        RUBY_METHOD_FUNC(__set_continuation__block),
+        context // data2
+        );
+}
+
+static VALUE
+__set_continuation__block(VALUE unused, VALUE in_context, int argc, VALUE argv[])
+{
+//     VALUE self =             rb_ary_entry(in_context, 0);
+    VALUE should_raise_ary = rb_ary_entry(in_context, 1);
+    VALUE c =                rb_ary_entry(in_context, 2);
+    VALUE proc = rb_block_proc();
+
+    // Here we set our `should_raise` pointer back to false
+    rb_ary_store(should_raise_ary, 0, Qfalse);
+    
+    return rb_funcall_with_block(c, id_call, argc, argv, proc);
+}
+
+
+
+
+

data/lib/mulligan/condition.rb

@@ -0,0 +1,88 @@
+module Mulligan
+
+  # An exception that is thrown when invoking a non-existent recovery.
+  class ControlException < Exception ; end
+
+  module Condition
+
+    # Creates or replaces a recovery strategy.
+    # 
+    # @param [String or Symbol] id the key to reference the recovery later
+    # @param [Hash] options specifies a token for this recovery that can later be
+    #               retrieved. Can only be set once. See {#recovery_options}
+    #               Reserved Keys are as follows:
+    #                 :data       - Use this as a parameter to send a piece of data to rescuers to use
+    #                               as they determine their strategy for recovering.
+    #                 :summary    - A short, one-line description of this recovery
+    #                 :discussion - The complete documentation of this recovery. Please include a
+    #                               description of the behavior, the return parameter, and any parameters
+    #                               the recovery can take
+    def set_recovery(id, options={}, &block)
+      return if block.nil?
+      recoveries[id.to_sym] = options.merge(:block => block)
+      nil
+    end
+    
+    # Checks for the presence of a recovery
+    # 
+    # @param [String or Symbol] id the key for the recovery
+    # @return [Boolean] whether or not a recovery exists for this id
+    def has_recovery?(id)
+      recoveries.has_key?(id.to_sym)
+    end
+    
+    # Retrieves the options specified when a recovery was made
+    # 
+    # @param [String or Symbol] id the key for the recovery
+    # @return [Hash] The options set on this recovery
+    def recovery_options(id)
+      return nil unless has_recovery?(id.to_sym)
+      recoveries[id.to_sym].dup.reject{|k,v| [:block, :continuation].include? k}
+    end
+  
+    # Retrieves all the identifiers for available recoveries
+    # 
+    # @return [Enumerable] The identifiers for all the recoveries
+    def recovery_identifiers
+      recoveries.keys
+    end
+  
+    # Executes the recovery.
+    # This actually places the stack back to just after the `#raise` that brought
+    # us to this `rescue` clause. Then the recovery block is executed and the program
+    # continues on.
+    # 
+    # @param [String or Symbol] id the key for the recovery
+    # @param params any additional parameters you want to pass to the recovery block
+    # @return This doesn't actually matter because you can't retrieve it
+    def recover(id, *params)
+      Thread.current[:__last_recovery__] = nil
+      raise ControlException unless has_recovery?(id.to_sym)
+      data = recoveries[id.to_sym]
+      if data[:continuation].nil?
+        $stderr.puts "Cannot invoke restart #{id}. Must first raise this exception: '#{self.inspect}'"
+        return
+      end
+      Thread.current[:__last_recovery__] = id
+      data[:continuation].call(*data[:block].call(*params))
+    end
+  
+  private
+
+    def recoveries
+      @recoveries ||= {}
+    end
+
+    def __set_continuation__
+      continuation = Proc.new
+      # the the continuation for any recoveries that are not yet assigned one
+      # It's important not to overwrite the existing continuations because a recovery
+      # should return to the place it was raised, always.
+      recoveries.each do |key, r|
+        next if r.has_key? :continuation
+        r[:continuation] = continuation
+      end
+    end
+  end
+end
+

data/lib/mulligan/kernel.rb

@@ -0,0 +1,4 @@
+require "mulligan/mulligan"
+require_relative 'kernel_common'
+
+# raise is implemented by the c-extension

data/lib/mulligan/kernel_common.rb

@@ -0,0 +1,12 @@
+require 'continuation'
+
+module Mulligan
+  module Kernel
+
+    # Returns the identifier for the last recovery invoked in this thread.
+    # @return [Symbol] The identifier of the last recovery invoked in this thread.
+    def last_recovery
+      Thread.current[:__last_recovery__]
+    end
+  end
+end

data/lib/mulligan/kernel_pure.rb

@@ -0,0 +1,31 @@
+require_relative 'kernel_common'
+
+module Mulligan
+  module Kernel
+
+    # Raises an Exception.
+    # The Exception that is either passed in or generated is yielded to the block
+    # where you can specify recoveries on it.
+    # 
+    # @param args the same args you would pass to the normal Kernel#raise
+    # @yield [e] Passes the exception-to-be-raised to the block.
+    # @return The value returned from the invoked recovery block.
+    def raise(*args)
+      super
+    rescue Exception => e
+      yield e if block_given?
+
+      # only use callcc if there are restarts otherwise re-raise it
+      super(e) if e.send(:recoveries).empty?
+      should_raise = true
+      result = callcc do |c|
+        e.send(:__set_continuation__) do |*args,&block|
+          should_raise = false
+          c.call(*args,&block)
+        end
+      end
+      super(e) if should_raise
+      result
+    end
+  end
+end

data/lib/mulligan/version.rb

@@ -0,0 +1,3 @@
+module Mulligan
+  VERSION = "0.4.1"
+end