cond 0.2.0

data/spec/specs_spec.rb

@@ -0,0 +1,16 @@
+here = File.dirname(__FILE__)
+require here + "/common"
+
+require 'quix/ruby'
+
+describe "specs" do
+  it "should run individually" do
+    (Dir["#{here}/*_spec.rb"] + Dir["#{here}/../examples/*_example.rb"]).each {
+      |spec|
+      unless File.basename(spec) == File.basename(__FILE__)
+        `"#{Quix::Ruby::EXECUTABLE}" "#{spec}"`
+        $?.exitstatus.should == 0
+      end
+    }
+  end
+end

data/spec/symbols_spec.rb

@@ -0,0 +1,33 @@
+require File.dirname(__FILE__) + "/common"
+
+#
+# Try to demonstrate symbol recycling by calling GC.start on each pass
+# through a symbol-generating loop.
+#
+# I have not yet seen jruby call the finalizers required for symbol
+# recycling.
+#
+
+def symbols_spec(&block)
+  if defined?(RUBY_ENGINE) and RUBY_ENGINE == "jruby"
+    xit "jruby failing #{File.basename(__FILE__)}", &block
+  else
+    it "should be recycled", &block
+  end
+end
+
+describe "generated symbols" do
+  symbols_spec do
+    histogram = Hash.new { |hash, key| hash[key] = 0 }
+
+    300.times { |n|
+      obj = Cond::CondPrivate::CodeSection.new(:foo)
+      leave, again = obj.instance_eval { [@leave, @again] }
+      histogram[leave] += 1
+      histogram[again] += 1
+      GC.start
+    }
+      
+    histogram.values.any? { |t| t > 1 }.should == true
+  end
+end

data/spec/thread_local_spec.rb

@@ -0,0 +1,29 @@
+require File.dirname(__FILE__) + "/common"
+
+require 'ostruct'
+
+describe "ThreadLocal" do
+  it "should keep independent values in separate threads" do
+    a = Cond::CondPrivate::ThreadLocal.new { OpenStruct.new }
+    a.value.x = 33
+    other_value = nil
+    Thread.new {
+      a.value.x = 44
+      other_value = a.value.x
+    }.join
+  
+    a.value.x.should == 33
+    other_value.should == 44
+    a.clear { 99 }
+    a.value.should == 99
+  end
+  
+  it "should work with included accessor_module" do
+    a = Class.new {
+      include Cond::CondPrivate::ThreadLocal.accessor_module(:x) { 33 }
+    }.new
+    a.x.should == 33
+    a.x = 44
+    a.x.should == 44
+  end
+end

data/spec/wrapping_spec.rb

@@ -0,0 +1,93 @@
+require File.dirname(__FILE__) + "/common"
+
+include Cond
+
+describe "singleton method defined in C" do
+  before :all do
+    @memo = []
+    @define_handler = lambda {
+      handle ArgumentError do
+        @memo.push :handled
+      end
+    }
+  end
+
+  describe "unwrapped" do
+    it "should unwind" do
+      lambda {
+        handling do
+          @define_handler.call
+          IO.read
+        end
+      }.should raise_error(ArgumentError)
+    end
+    
+    it "should not call handler" do
+      @memo.should == []
+    end
+  end
+
+  describe "wrapped" do
+    before :all do
+      Cond.wrap_singleton_method(IO, :read)
+    end
+    
+    it "should not unwind" do
+      lambda {
+        handling do
+          @define_handler.call
+          IO.read
+        end
+      }.should_not raise_error(ArgumentError)
+    end
+
+    it "should call handler" do
+      @memo.should == [:handled]
+    end
+  end
+end
+
+describe "instance method defined in C" do
+  before :all do
+    @memo = []
+    @define_handler = lambda {
+      handle ZeroDivisionError do |exception|
+        @memo.push :handled
+      end
+    }
+  end
+
+  describe "unwrapped" do
+    it "should unwind" do
+      lambda {
+        handling do
+          @define_handler.call
+          3/0
+        end
+      }.should raise_error(ZeroDivisionError)
+    end
+
+    it "should not call handler" do
+      @memo.should == []
+    end
+  end
+
+  describe "wrapped" do
+    before :all do
+      Cond.wrap_instance_method(Fixnum, :/)
+    end
+    
+    it "should not unwind" do
+      lambda {
+        handling do
+          @define_handler.call
+          3/0
+        end
+      }.should_not raise_error(ZeroDivisionError )
+    end
+
+    it "should call handler" do
+      @memo.should == [:handled]
+    end
+  end
+end

data/support/quix/ruby.rb

@@ -0,0 +1,51 @@
+
+require 'rbconfig'
+
+module Quix
+  module Ruby
+    EXECUTABLE = lambda {
+      name = File.join(
+        Config::CONFIG["bindir"],
+        Config::CONFIG["RUBY_INSTALL_NAME"]
+      )
+
+      if Config::CONFIG["host"] =~ %r!(mswin|cygwin|mingw)! and
+          File.basename(name) !~ %r!\.(exe|com|bat|cmd)\Z!i
+        name + ".exe"
+      else
+        name
+      end
+    }.call
+
+    class << self
+      def run(*args)
+        system(EXECUTABLE, *args)
+      end
+
+      def run_or_raise(*args)
+        cmd = [EXECUTABLE, *args]
+        unless system(*cmd)
+          msg = (
+            "failed to launch ruby: " +
+            "system(*#{cmd.inspect}) failed with status #{$?.exitstatus}"
+          )
+          raise msg
+        end
+      end
+
+      def with_warnings(value = true)
+        previous = $VERBOSE
+        $VERBOSE = value
+        begin
+          yield
+        ensure
+          $VERBOSE = previous
+        end
+      end
+      
+      def no_warnings(&block)
+        with_warnings(false, &block)
+      end
+    end
+  end
+end

data/support/quix/simple_installer.rb

@@ -0,0 +1,88 @@
+
+require 'rbconfig'
+require 'fileutils'
+require 'find'
+
+module Quix
+  class SimpleInstaller
+    def initialize
+      dest_root = Config::CONFIG["sitelibdir"]
+      sources = []
+      Find.find("./lib") { |source|
+        if install_file?(source)
+          sources << source
+        end
+      }
+      @spec = sources.inject(Array.new) { |acc, source|
+        if source == "./lib"
+          acc
+        else
+          dest = File.join(dest_root, source.sub(%r!\A\./lib!, ""))
+  
+          install = lambda {
+            if File.directory?(source)
+              unless File.directory?(dest)
+                puts "mkdir #{dest}"
+                FileUtils.mkdir(dest)
+              end
+            else
+              puts "install #{source} --> #{dest}"
+              FileUtils.install(source, dest)
+            end
+          }
+            
+          uninstall = lambda {
+            if File.directory?(source)
+              if File.directory?(dest)
+                puts "rmdir #{dest}"
+                FileUtils.rmdir(dest)
+              end
+            else
+              if File.file?(dest)
+                puts "rm #{dest}"
+                FileUtils.rm(dest)
+              end
+            end
+          }
+  
+          acc << {
+            :source => source,
+            :dest => dest,
+            :install => install,
+            :uninstall => uninstall,
+          }
+        end
+      }
+    end
+  
+    def install_file?(source)
+      !File.symlink?(source) and
+        (File.directory?(source) or
+          (File.file?(source) and File.extname(source) == ".rb"))
+    end
+
+    attr_accessor :spec
+
+    def install
+      @spec.each { |entry|
+        entry[:install].call
+      }
+    end
+  
+    def uninstall
+      @spec.reverse.each { |entry|
+        entry[:uninstall].call
+      }
+    end
+
+    def run(args = ARGV)
+      if args.empty? or (args.size == 1 and args.first == "install")
+        install
+      elsif args.size == 1 and args.first == "--uninstall"
+        uninstall
+      else
+        raise "unrecognized arguments: #{args.inspect}"
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,93 @@
+--- !ruby/object:Gem::Specification 
+name: cond
+version: !ruby/object:Gem::Version 
+  version: 0.2.0
+platform: ruby
+authors: 
+- James M. Lawrence
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-03-22 00:00:00 -04:00
+default_executable: 
+dependencies: []
+
+description: +Cond+ allows errors to be handled at the place where they occur. You decide whether or not the stack should be unwound, depending on the circumstance and the error.
+email: quixoticsycophant@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- README
+files: 
+- README
+- cond.gemspec
+- ./examples/bad_example.rb
+- ./examples/calc_example.rb
+- ./examples/readme_example.rb
+- ./examples/restarts_example.rb
+- ./examples/seibel_example.rb
+- ./install.rb
+- ./lib/cond/cond_private/defaults.rb
+- ./lib/cond/cond_private/symbol_generator.rb
+- ./lib/cond/cond_private/thread_local.rb
+- ./lib/cond.rb
+- ./readmes/restarts.rb
+- ./readmes/seibel_pcl.rb
+- ./spec/basic_spec.rb
+- ./spec/common.rb
+- ./spec/error_spec.rb
+- ./spec/leave_again_spec.rb
+- ./spec/matching_spec.rb
+- ./spec/raise_spec.rb
+- ./spec/reraise_spec.rb
+- ./spec/specs_spec.rb
+- ./spec/symbols_spec.rb
+- ./spec/thread_local_spec.rb
+- ./spec/wrapping_spec.rb
+- ./support/quix/ruby.rb
+- ./support/quix/simple_installer.rb
+- ./Rakefile
+has_rdoc: true
+homepage: cond.rubyforge.org
+post_install_message: 
+rdoc_options: 
+- --main
+- README
+- --title
+- "cond: Resolve errors without unwinding the stack."
+- --exclude
+- spec
+- --exclude
+- examples
+- --exclude
+- readmes
+- --exclude
+- support
+- --exclude
+- lib/cond/cond_private
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: cond
+rubygems_version: 1.3.1
+signing_key: 
+specification_version: 2
+summary: Resolve errors without unwinding the stack.
+test_files: []
+