strand 0.1.0

data/.document

@@ -0,0 +1,6 @@
+lib/**/*.rb
+bin/*
+- 
+features/**/*.feature
+LICENSE.txt
+README.rdoc

data/.rspec

@@ -0,0 +1 @@
+--color

data/Gemfile

@@ -0,0 +1,16 @@
+source "http://rubygems.org"
+# Add dependencies required to use your gem here.
+# Example:
+#   gem "activesupport", ">= 2.3.5"
+
+# Add dependencies to develop your gem here.
+# Include everything needed to run rake, tests, features, etc.
+group :development do
+  gem "bundler", "~> 1.0.0"
+  gem "em-spec"
+  gem "eventmachine", "~> 0.12.0"
+  gem "jeweler", "~> 1.6.4"
+  gem "rcov", ">= 0"
+  gem "rr"
+  gem "rspec"
+end

data/Gemfile.lock

@@ -0,0 +1,40 @@
+GEM
+  remote: http://rubygems.org/
+  specs:
+    bacon (1.1.0)
+    diff-lcs (1.1.2)
+    em-spec (0.2.5)
+      bacon
+      eventmachine
+      rspec (~> 2.6.0)
+      test-unit
+    eventmachine (0.12.10)
+    git (1.2.5)
+    jeweler (1.6.4)
+      bundler (~> 1.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.9.2)
+    rcov (0.9.9)
+    rr (1.0.3)
+    rspec (2.6.0)
+      rspec-core (~> 2.6.0)
+      rspec-expectations (~> 2.6.0)
+      rspec-mocks (~> 2.6.0)
+    rspec-core (2.6.4)
+    rspec-expectations (2.6.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.6.0)
+    test-unit (2.3.2)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  em-spec
+  eventmachine (~> 0.12.0)
+  jeweler (~> 1.6.4)
+  rcov
+  rr
+  rspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Christopher J. Bottaro
+
+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.rdoc

@@ -0,0 +1,173 @@
+= strand
+
+Strand is a class that wraps Fibers and gives them Thread-like behavior by using EventMachine.
+
+Strand::ConditionVariable provides functionality for Fibers similar to Ruby's built in ConditionVariable for Threads.
+
+== Like Threads
+
+Strand has an interface similar to Thread.
+
+  thread = Thread.new{ 1+2 }
+  thread.join
+  thread.value # => 3
+  
+  strand = Strand.new{ 1+2 }
+  strand.join
+  strand.value # => 3
+
+== Fiber/EventMachine aware sleep
+
+Calling sleep usually results in EventMachine's reactor being blocked, but Strand defines an EM+Fiber safe sleep.
+
+Consider mimicking the following threaded code:
+
+  t1 = Thread.new{ sleep(1) }
+  t2 = Thread.new{ sleep(1) }
+  t1.join
+  t2.join
+  # Roughly 1 second will have passed.
+
+Assuming that EventMachine is running:
+
+  s1 = Strand.new{ Strand.sleep(1) }
+  s2 = Strand.new{ Strand.sleep(1) }
+  s1.join
+  s2.join
+  # Roughly 1 second will have passed.
+
+== Thread local, Fiber local and Strand local variables
+
+Thread local storage is the same as Fiber local storage in Ruby.
+
+  Thread.current[:name] = "callie"
+  Fiber.current[:name]  # => "callie"
+  Fiber.current[:name]  = "coco"
+  Thread.current[:name] # => "coco"
+
+Strand provides its own storage.
+
+  Thread.current[:name] = "callie"
+  Strand.current[:name] = "coco"
+  Thread.current[:name] # => "callie"
+  Strand.current[:name] # => "coco"
+
+== Strand.list
+
+Ruby provides a way to get a list of all living Threads:
+
+  Thread.new{ sleep }
+  Thread.list # => [#<Thread:0x007f9343869da8 run>, #<Thread:0x007f934405eec8 sleep>]
+
+There is no equivalent for finding all living Fibers.
+
+There is a way to find all living Strands though:
+
+  Strand.new do
+    Strand.new{ Strand.yield }
+    Strand.list # => [#<Strand:0x70358087608460 run, #<Strand:0x70358087608280 yielded]
+  end
+
+== Strand.pass
+
+Consider the following threaded code:
+
+  Thread.new do
+    puts 1
+    Thread.pass
+    puts 2
+    Thread.pass
+    puts 3
+  end
+  Thread.new do
+    puts 1
+    Thread.pass
+    puts 2
+    Thread.pass
+    puts 3
+  end
+
+Or similarly:
+
+  Thread.new do
+    puts 1
+    sleep(0.01)
+    puts 2
+    sleep(0.01)
+    puts 3
+  end
+  Thread.new do
+    puts 1
+    sleep(0.01)
+    puts 2
+    sleep(0.01)
+    puts 3
+  end
+
+How would you do that with fibers?
+
+  Fiber.new do
+    puts 1
+    Fiber.yield
+    puts 2
+    Fiber.yield
+    puts 3
+  end.resume
+  Fiber.new do
+    puts 1
+    Fiber.yield
+    puts 2
+    Fiber.yield
+    puts 3
+  end.resume
+
+That doesn't work.  The fibers are yielding, but nothing is resuming them.  The output is just:
+
+  1
+  1
+
+Enter <tt>Strand.pass</tt>.  It yields the fiber, but tells EventMachine to resume it on the next tick.
+
+  Strand.new do
+    puts 1
+    Strand.pass
+    puts 2
+    Strand.pass
+    puts 3
+  end
+  Strand.new do
+    puts 1
+    Strand.pass
+    puts 2
+    Strand.pass
+    puts 3
+  end
+
+The output is:
+
+  1
+  1
+  2
+  2
+  3
+  3
+
+== RDoc
+
+{\http://doc.stochasticbytes.com/strand/index.html}[http://doc.stochasticbytes.com/strand/index.html]
+
+== Contributing to strand
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Christopher J. Bottaro. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,64 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "strand"
+  gem.homepage = "http://github.com/cjbottaro/strand"
+  gem.license = "MIT"
+  gem.summary = %Q{Make fibers behave like threads using EventMachine.}
+  gem.description = %Q{Get thread-like behavior from fibers using EventMachine.}
+  gem.email = "cjbottaro@alumni.cs.utexas.edu"
+  gem.authors = ["Christopher J. Bottaro"]
+  # dependencies defined in Gemfile
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rake/testtask'
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib' << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+end
+
+require 'rcov/rcovtask'
+Rcov::RcovTask.new do |test|
+  test.libs << 'test'
+  test.pattern = 'test/**/test_*.rb'
+  test.verbose = true
+  test.rcov_opts << '--exclude "gems/*"'
+end
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :test
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "strand #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.1.0

data/lib/strand.rb

@@ -0,0 +1,132 @@
+require "fiber"
+require "eventmachine"
+require "strand/condition_variable"
+
+class Strand
+
+  @@strands = {}
+
+  # The strand's underlying fiber.
+  attr_reader :fiber
+
+  # Return an array of all Strands that are alive.
+  def self.list
+    @@strands.values
+  end
+
+  # Get the currently running strand.  Primarily used to access "strand local" variables.
+  def self.current
+    @@strands[Fiber.current]
+  end
+
+  # EM/fiber safe sleep.
+  def self.sleep(seconds)
+    fiber = Fiber.current
+    EM::Timer.new(seconds){ fiber.resume }
+    Fiber.yield
+  end
+
+  # Alias for Fiber.yield.
+  def self.yield
+    Fiber.yield
+  end
+
+  # Yield the strand, but have EM resume it on the next tick.
+  def self.pass
+    fiber = Fiber.current
+    EM.next_tick{ fiber.resume }
+    Fiber.yield
+  end
+
+  # Create and run a strand.
+  def initialize(&block)
+
+    # Initialize our "fiber local" storage.
+    @locals = {}
+
+    # Condition variable for joining.
+    @join_cond = ConditionVariable.new
+
+    # Create our fiber.
+    @fiber = Fiber.new{ fiber_body(&block) }
+
+    # Add us to the list of living strands.
+    @@strands[@fiber] = self
+
+    # Finally start the strand.
+    resume
+  end
+
+  # Like Thread#join.
+  #   s1 = Strand.new{ Strand.sleep(1) }
+  #   s2 = Strand.new{ Strand.sleep(1) }
+  #   s1.join
+  #   s2.join
+  def join
+    @join_cond.wait if alive?
+    raise @exception if @exception
+    true
+  end
+
+  # Like Fiber#resume.
+  def resume
+    @fiber.resume
+  end
+
+  # Like Thread#alive? or Fiber#alive?
+  def alive?
+    @fiber.alive?
+  end
+
+  # Like Thread#value.  Implicitly calls #join.
+  #   strand = Strand.new{ 1+2 }
+  #   strand.value # => 3
+  def value
+    join and @value
+  end
+
+  # Access to "strand local" variables, akin to "thread local" variables.
+  #   Strand.new do
+  #     ...
+  #     Strand.current[:connection].send(data)
+  #     ...
+  #   end
+  def [](name)
+    @locals[name]
+  end
+
+  # Access to "strand local" variables, akin to "thread local" variables.
+  #   Strand.new do
+  #     ...
+  #     Strand.current[:connection] = SomeConnectionClass.new(host, port)
+  #     ...
+  #   end
+  def []=(name, value)
+    @locals[name] = value
+  end
+
+  def inspect #:nodoc:
+    "#<Strand:0x%s %s" % [object_id, @fiber == Fiber.current ? "run" : "yielded"]
+  end
+
+protected
+  
+  def fiber_body(&block) #:nodoc:
+    # Run the strand's block and capture the return value.
+    begin
+      @value = block.call
+    rescue StandardError => e
+      @exception = e
+    end
+
+    # Mark the strand as finished running.
+    @finished = true
+
+    # Delete from the list of running stands.
+    @@strands.delete(@fiber)
+
+    # Resume anyone who called join on us.
+    @join_cond.signal
+  end
+
+end

data/lib/strand/atc.rb

@@ -0,0 +1,41 @@
+class Strand
+  class Atc #:nodoc:
+    
+    def initialize(options = {})
+      @timeout  = options[:timeout]
+      @cond     = ConditionVariable.new
+      @states   = []
+    end
+
+    # Wait for state to happen.
+    def wait(state, timeout = nil)
+      return true if @states.include?(state)
+      timeout ||= @timeout
+      if timeout
+        wait_with_timeout(state, timeout)
+      else
+        wait_without_timeout(state)
+      end
+    end
+
+    def signal(state)
+      @states << state
+      @cond.signal
+    end
+
+  private
+    
+    def wait_with_timeout(state, timeout)
+      while not @states.include?(state)
+        return @states.include?(state) if @cond.wait(timeout) == false
+      end
+      true
+    end
+
+    def wait_without_timeout(state)
+      @cond.wait while not @states.include?(state)
+      true
+    end
+
+  end
+end

data/lib/strand/condition_variable.rb

@@ -0,0 +1,78 @@
+class Strand
+  # Provides for Strands (Fibers) what Ruby's ConditionVariable provides for Threads.
+  class ConditionVariable
+
+    # Create a new condition variable.
+    def initialize
+      @waiters = []
+    end
+
+    # Wait until signaled.  Returns true upon returning.
+    #   x = nil
+    #   cond = Strand::ConditionVariable.new
+    #   Strand.new{ cond.wait; x = 1; cond.signal }
+    #   puts x # => nil
+    #   cond.signal
+    #   cond.wait # => true
+    #   puts x # => 1
+    # If timeout is a number, then returns false if timed out or true if signaled.
+    #   x = nil
+    #   cond = Strand::ConditionVariable.new
+    #   Strand.new{ cond.wait; x = 1; cond.signal }
+    #   puts x # => nil
+    #   cond.wait(0.01) # => false
+    #   puts x # => nil
+    def wait(timeout = nil)
+      # Get the fiber that called us.
+      fiber = Fiber.current
+
+      # Add the fiber to the list of waiters.
+      @waiters << fiber
+
+      # Setup the timer if they specified a timeout
+      timer = EM::Timer.new(timeout){ fiber.resume(:timeout) } if timeout
+
+      # Wait for signal or timeout.
+      if Fiber.yield == :timeout
+        # Timeout occurred.
+
+        # Remove from list of waiters.
+        @waiters.delete(fiber)
+
+        false
+      else
+        # Ok we were signaled.
+
+        # Cancel the timer if there is one.
+        timer.cancel if timer
+
+        true
+      end
+
+    end
+
+    # Asynchronously resume a fiber waiting on this condition variable.
+    # The waiter is not resumed immediately, but on the next tick of EM's reactor loop.
+    #   cond = Strand::ConditionVariable.new
+    #   Strand.new{ puts 1; cond.wait; puts 2 }
+    #   puts 3
+    #   cond.signal
+    #   puts 4
+    #   # output is...
+    #   1
+    #   3
+    #   4
+    #   2
+    def signal
+      # If there are no waiters, do nothing.
+      return if @waiters.empty?
+
+      # Find a waiter to wake up.
+      waiter = @waiters.shift
+
+      # Resume it on next tick.
+      EM.next_tick{ waiter.resume }
+    end
+
+  end
+end

data/spec/condition_variable_spec.rb

@@ -0,0 +1,82 @@
+require "spec_helper"
+
+describe Strand::ConditionVariable do
+  include EM::SpecHelper
+
+  context "calling #wait" do
+    before(:each) do
+      @cond = described_class.new
+      @atc = Atc.new :timeout => 0.01
+    end
+    it "should block until signaled" do
+      em do
+        Strand.new{ @cond.wait; @atc.signal(1) }
+        @atc.wait(1).should be_false
+        @cond.signal
+        @atc.wait(1).should be_true
+        done
+      end
+    end
+    it "should block until timed out" do
+      em do
+        Strand.new{ @cond.wait(0.02); @atc.signal(1) }
+        @atc.wait(1).should be_false
+        @atc.wait(1).should be_true
+        done
+      end
+    end
+  end
+
+  context "calling #signal" do
+    context "with no waiters" do
+      before(:all){ @cond = described_class.new }
+      it "should not do anything" do
+        @cond.signal.should be_nil
+      end
+    end
+    context "with a single waiter" do
+      before(:all) do
+        @cond = described_class.new
+        @atc = Atc.new :timeout => 0.01
+        Strand.new{ @cond.wait; @atc.signal(1) }
+      end
+      it "should wake up the waiter" do
+        em do
+          @atc.wait(1).should be_false
+          @cond.signal
+          @atc.wait(1).should be_true
+          done
+        end
+      end
+    end
+    context "with multiple waiters" do
+      before(:all) do
+        @cond = described_class.new
+        @atc = Atc.new :timeout => 0.01
+        Strand.new{ @cond.wait; @atc.signal(1) }
+        Strand.new{ @cond.wait; @atc.signal(2) }
+      end
+      it "should wake up the first waiter" do
+        em do
+          @atc.wait(1).should be_false
+          @atc.wait(2).should be_false
+          @cond.signal
+          @atc.wait(1).should be_true
+          @atc.wait(2).should be_false
+          done
+        end
+      end
+      it "then wake up the second waiter" do
+        em do
+          @atc.wait(1).should be_true
+          @atc.wait(2).should be_false
+          @cond.signal
+          @atc.wait(1).should be_true
+          @atc.wait(2).should be_true
+          done
+        end
+      end
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,17 @@
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'strand'
+Bundler.require(:development)
+
+# Requires supporting files with custom matchers and macros, etc,
+# in ./support/ and its subdirectories.
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each {|f| require f}
+
+RSpec.configure do |config|
+  config.mock_with :rr
+end
+
+require "strand/atc"
+Atc = Strand::Atc
+
+require "em-spec/rspec"

data/test/helper.rb

@@ -0,0 +1,30 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'strand'
+
+class Test::Unit::TestCase
+
+  def self.test(name, &block)
+    name = "test_#{name}" unless name[0,5] == "test_"
+    define_method(name) do
+      EM.run do
+        Fiber.new do
+          instance_eval(&block)
+          EM.stop
+        end.resume
+      end
+    end
+  end
+
+end

data/test/test_strand.rb

@@ -0,0 +1,121 @@
+require 'helper'
+
+class TestStrand < Test::Unit::TestCase
+
+  test "em" do
+    results = []
+
+    s1 = Strand.new do
+      results << "1a"
+      Strand.sleep(0.1)
+      results << "1b"
+      Strand.sleep(0.1)
+      results << "1c"
+    end
+    
+    s2 = Strand.new do
+      results << "2a"
+      Strand.sleep(0.1)
+      results << "2b"
+      Strand.sleep(0.1)
+      results << "2c"
+    end
+
+    s1.join
+    s2.join
+
+    assert_equal false, s1.alive?
+    assert_equal false, s2.alive?
+    assert_equal %w[1a 2a 1b 2b 1c 2c], results
+  end
+
+  test "yield" do
+    results = []
+
+    s1 = Strand.new do
+      results << "1a"
+      Strand.pass
+      results << "1b"
+      Strand.pass
+      results << "1c"
+    end
+    
+    s2 = Strand.new do
+      results << "2a"
+      Strand.pass
+      results << "2b"
+      Strand.pass
+      results << "2c"
+    end
+
+    s1.join
+    s2.join
+
+    assert_equal false, s1.alive?
+    assert_equal false, s2.alive?
+    assert_equal %w[1a 2a 1b 2b 1c 2c], results
+  end
+
+  test "improper_yield" do
+    test_fiber = Fiber.current
+    strand = Strand.new do
+      fiber = Fiber.current
+      EM::Timer.new(0.01) do
+        assert_raise(FiberError){ fiber.resume }
+        test_fiber.resume
+      end
+      Strand.pass
+    end
+
+    assert strand.join
+    Fiber.yield
+  end
+
+  test "improper_pass" do
+    fiber = nil
+    strand = Strand.new do
+      fiber = Fiber.current
+      Strand.pass
+      Strand.yield
+    end
+    fiber.resume
+  end
+
+  test "strand_list" do
+    Strand.new do
+      Strand.new{ Strand.yield }
+      assert Strand.list.inspect =~ /#<Strand:0x(.+) run>, #<Strand:0x(.+) yielded>/
+    end
+  end
+
+  test "wait" do
+    x = nil
+    cond = Strand::ConditionVariable.new
+    Strand.new{ cond.wait; x = 1; cond.signal }
+    assert_nil x
+    cond.signal
+    cond.wait
+    assert_equal 1, x
+  end
+
+  test "wait_timeout" do
+    x = nil
+    cond = Strand::ConditionVariable.new
+    Strand.new{ cond.wait; x = 1; cond.signal }
+    assert_nil x
+    cond.wait(0.01)
+    assert_nil x
+  end
+
+  test "signal" do
+    result = []
+    cond = Strand::ConditionVariable.new
+    strand = Strand.new{ result << 1; cond.wait; result << 2 }
+    result << 3
+    cond.signal
+    result << 4
+    strand.join
+    assert_equal [1, 3, 4, 2], result
+  end
+
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: strand
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Christopher J. Bottaro
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: &70284397102060 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.0.0
+  type: :development
+  prerelease: false
+  version_requirements: *70284397102060
+- !ruby/object:Gem::Dependency
+  name: em-spec
+  requirement: &70284397100280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70284397100280
+- !ruby/object:Gem::Dependency
+  name: eventmachine
+  requirement: &70284397098140 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: *70284397098140
+- !ruby/object:Gem::Dependency
+  name: jeweler
+  requirement: &70284397153900 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 1.6.4
+  type: :development
+  prerelease: false
+  version_requirements: *70284397153900
+- !ruby/object:Gem::Dependency
+  name: rcov
+  requirement: &70284397151160 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70284397151160
+- !ruby/object:Gem::Dependency
+  name: rr
+  requirement: &70284397150240 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70284397150240
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &70284397293200 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *70284397293200
+description: Get thread-like behavior from fibers using EventMachine.
+email: cjbottaro@alumni.cs.utexas.edu
+executables: []
+extensions: []
+extra_rdoc_files:
+- LICENSE.txt
+- README.rdoc
+files:
+- .document
+- .rspec
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.rdoc
+- Rakefile
+- VERSION
+- lib/strand.rb
+- lib/strand/atc.rb
+- lib/strand/condition_variable.rb
+- spec/condition_variable_spec.rb
+- spec/spec_helper.rb
+- test/helper.rb
+- test/test_strand.rb
+homepage: http://github.com/cjbottaro/strand
+licenses:
+- MIT
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+      segments:
+      - 0
+      hash: -933947513672593859
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.7
+signing_key: 
+specification_version: 3
+summary: Make fibers behave like threads using EventMachine.
+test_files: []