fiber18 1.0.0

data/.gitignore

@@ -0,0 +1,2 @@
+*.gem
+pkg/*

data/README

@@ -0,0 +1,21 @@
+Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
+  (c) 2008 Aman Gupta (tmm1)
+
+== Usage
+
+f = Fiber.new{ |sym|
+  p(sym)
+  puts 'hi'
+  p(Fiber.yield 1)
+  puts 'bye'
+  :end
+}
+p(f.resume :begin)
+p(f.resume 2)
+
+:begin
+hi
+1
+2
+bye
+:end

data/Rakefile

@@ -0,0 +1,8 @@
+task :test do
+  # sh 'ruby -Ilib -rfiber18 test/test_fiber.rb'
+  $:.unshift 'lib'
+  require 'fiber18'
+  require 'test/test_fiber'
+end
+
+task :default => :test

data/fiber18.gemspec

@@ -0,0 +1,19 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "fiber18"
+  s.version     = "1.0.0" 
+  s.authors     = [""]
+  s.email       = [""]
+  s.homepage    = "http://github.com/tmm1/fiber18"
+  s.summary     = %q{API compatible Thread based Fiber implementation for Ruby 1.8}
+  s.description = %q{API compatible Thread based Fiber implementation for Ruby 1.8 (including JRuby in 1.8 mode)}
+
+  s.rubyforge_project = "fiber18"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+end

data/lib/fiber18.rb

@@ -0,0 +1,96 @@
+# Poor Man's Fiber (API compatible Thread based Fiber implementation for Ruby 1.8)
+# (c) 2008 Aman Gupta (tmm1)
+
+unless defined? Fiber
+  $:.unshift File.expand_path(File.dirname(__FILE__)) + '/compat'
+  require 'thread'
+
+  class FiberError < StandardError; end
+
+  class Fiber
+    def initialize
+      raise ArgumentError, 'new Fiber requires a block' unless block_given?
+
+      @yield = Queue.new
+      @resume = Queue.new
+
+      @thread = Thread.new{ @yield.push [yield(*@resume.pop)] }
+      @thread.abort_on_exception = true
+      @thread[:fiber] = self
+    end
+    attr_reader :thread
+
+    def resume *args
+      raise FiberError, 'dead fiber called' unless @thread.alive?
+      @resume.push(args)
+      result = @yield.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def yield *args
+      @yield.push(args)
+      result = @resume.pop
+      result.size > 1 ? result : result.first
+    end
+
+    def self.yield *args
+      if fiber = Thread.current[:fiber]
+        fiber.yield(*args)
+      else
+        raise FiberError, 'not inside a fiber'
+      end
+    end
+
+    def self.current
+      if Thread.current == Thread.main
+        return Thread.main[:fiber] ||= RootFiber.new
+      end
+
+      Thread.current[:fiber] or raise FiberError, 'not inside a fiber'
+    end
+
+    def inspect
+      "#<#{self.class}:0x#{self.object_id.to_s(16)}>"
+    end
+  end
+
+  class RootFiber < Fiber
+    def initialize
+      # XXX: what is a root fiber anyway?
+    end
+
+    def self.yield *args
+      raise FiberError, "can't yield from root fiber"
+    end
+  end
+end
+
+if __FILE__ == $0
+  f = Fiber.new{ |sym|
+    p(sym)
+    puts 'hi'
+    p(Fiber.yield 1)
+    puts 'bye'
+    :end
+  }
+  p(f.resume :begin)
+  p(f.resume 2)
+end
+
+__END__
+
+$ ruby fbr.rb
+:begin
+hi
+1
+2
+bye
+:end
+
+$ ruby1.9 fbr.rb
+:begin
+hi
+1
+2
+bye
+:end

data/test/test_fiber.rb

@@ -0,0 +1,165 @@
+require 'test/unit'
+require 'fiber'
+require 'continuation'
+
+class TestFiber < Test::Unit::TestCase
+  def test_normal
+    f = Fiber.current
+    assert_equal(:ok2,
+      Fiber.new{|e|
+        assert_equal(:ok1, e)
+        Fiber.yield :ok2
+      }.resume(:ok1)
+    )
+    assert_equal([:a, :b], Fiber.new{|a, b| [a, b]}.resume(:a, :b))
+  end
+
+  def test_term
+    assert_equal(:ok, Fiber.new{:ok}.resume)
+    assert_equal([:a, :b, :c, :d, :e],
+      Fiber.new{
+        Fiber.new{
+          Fiber.new{
+            Fiber.new{
+              [:a]
+            }.resume + [:b]
+          }.resume + [:c]
+        }.resume + [:d]
+      }.resume + [:e])
+  end
+
+  def test_many_fibers
+    max = 10000
+    assert_equal(max, max.times{
+      Fiber.new{}
+    })
+    assert_equal(max,
+      max.times{|i|
+        Fiber.new{
+        }.resume
+      }
+    )
+  end
+end
+__END__
+
+  def test_many_fibers_with_threads
+    max = 1000
+    @cnt = 0
+    (1..100).map{|ti|
+      Thread.new{
+        max.times{|i|
+          Fiber.new{
+            @cnt += 1
+          }.resume
+        }
+      }
+    }.each{|t|
+      t.join
+    }
+    assert_equal(:ok, :ok)
+  end
+
+  def test_error
+    assert_raise(ArgumentError){
+      Fiber.new # Fiber without block
+    }
+    assert_raise(FiberError){
+      f = Fiber.new{}
+      Thread.new{f.resume}.join # Fiber yielding across thread
+    }
+    assert_raise(FiberError){
+      f = Fiber.new{}
+      f.resume
+      f.resume
+    }
+    assert_raise(RuntimeError){
+      f = Fiber.new{
+        @c = callcc{|c| @c = c}
+      }.resume
+      @c.call # cross fiber callcc
+    }
+    assert_raise(RuntimeError){
+      Fiber.new{
+        raise
+      }.resume
+    }
+    assert_raise(FiberError){
+      Fiber.yield
+    }
+    assert_raise(FiberError){
+      fib = Fiber.new{
+        fib.resume
+      }
+      fib.resume
+    }
+    assert_raise(FiberError){
+      fib = Fiber.new{
+        Fiber.new{
+          fib.resume
+        }.resume
+      }
+      fib.resume
+    }
+  end
+
+  def test_return
+    assert_raise(LocalJumpError){
+      Fiber.new do
+        return
+      end.resume
+    }
+  end
+
+  def test_throw
+    assert_raise(ArgumentError){
+      Fiber.new do
+        throw :a
+      end.resume
+    }
+  end
+
+  def test_transfer
+    ary = []
+    f2 = nil
+    f1 = Fiber.new{
+      ary << f2.transfer(:foo)
+      :ok
+    }
+    f2 = Fiber.new{
+      ary << f1.transfer(:baz)
+      :ng
+    }
+    assert_equal(:ok, f1.transfer)
+    assert_equal([:baz], ary)
+  end
+
+  def test_tls
+    # 
+    def tvar(var, val)
+      old = Thread.current[var]
+      begin
+        Thread.current[var] = val
+        yield
+      ensure
+        Thread.current[var] = old
+      end
+    end
+
+    fb = Fiber.new {
+      assert_equal(nil, Thread.current[:v]); tvar(:v, :x) {
+      assert_equal(:x,  Thread.current[:v]);   Fiber.yield
+      assert_equal(:x,  Thread.current[:v]); }
+      assert_equal(nil, Thread.current[:v]); Fiber.yield
+      raise # unreachable
+    }
+
+    assert_equal(nil, Thread.current[:v]); tvar(:v,1) {
+    assert_equal(1,   Thread.current[:v]);   tvar(:v,3) {
+    assert_equal(3,   Thread.current[:v]);     fb.resume
+    assert_equal(3,   Thread.current[:v]);   }
+    assert_equal(1,   Thread.current[:v]); }
+    assert_equal(nil, Thread.current[:v]); fb.resume
+    assert_equal(nil, Thread.current[:v]);
+  end
+end

metadata

@@ -0,0 +1,62 @@
+--- !ruby/object:Gem::Specification 
+name: fiber18
+version: !ruby/object:Gem::Version 
+  prerelease: 
+  version: 1.0.0
+platform: ruby
+authors: 
+  - ""
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2012-03-07 00:00:00 Z
+dependencies: []
+
+description: API compatible Thread based Fiber implementation for Ruby 1.8 (including JRuby in 1.8 mode)
+email: 
+  - ""
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+  - .gitignore
+  - README
+  - Rakefile
+  - fiber18.gemspec
+  - lib/compat/continuation.rb
+  - lib/compat/fiber.rb
+  - lib/fiber18.rb
+  - test/test_fiber.rb
+homepage: http://github.com/tmm1/fiber18
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+requirements: []
+
+rubyforge_project: fiber18
+rubygems_version: 1.8.15
+signing_key: 
+specification_version: 3
+summary: API compatible Thread based Fiber implementation for Ruby 1.8
+test_files: []
+