concurrent-selectable 0.1 → 0.1.1

data/lib/concurrent/selectable/channel.rb

@@ -64,6 +64,7 @@ class Channel < Base
       wait
     end
   end
+  alias_method :receive, :get
 
   # Places +value+ on the channel.
   def put(value)

data/lib/concurrent/selectable/common.rb

@@ -62,6 +62,16 @@ class Base
     @read
   end
 
+  # Manually releases the IO resources associated with the primitive
+  def close
+    [ @read, @write ].each do |port|
+      begin
+        port.close
+      rescue Exception
+      end
+    end
+  end
+
 private
   def internal_set
     @write.write 'x'

data/lib/concurrent/selectable/semaphore.rb

@@ -48,9 +48,21 @@ class Semaphore < Base
     @count = count
   end
 
+  # Increments the semaphore
+  def signal
+    @lock.synchronize do
+      internal_set if @count.zero?
+      @count += 1
+    end
+    self
+  end
+  alias_method :put, :signal
+  alias_method :up, :signal
+  alias_method :v, :signal
+
   # Decrements the semaphore, blocking if its count is already zero and
   # +blocking+ is true.
-  def get(blocking=true)
+  def wait(blocking=true)
     loop do
       @lock.synchronize do
         if @count.nonzero?
@@ -60,17 +72,22 @@ class Semaphore < Base
         end
       end
       return nil unless blocking
-      wait
+      super()
     end
   end
+  alias_method :get, :wait
+  alias_method :down, :wait
+  alias_method :p, :wait
 
-  # Increments the semaphore
-  def put
-    @lock.synchronize do
-      internal_set if @count.zero?
-      @count += 1
+  def exclusive
+    wait
+    begin
+      yield
+    ensure
+      signal
     end
   end
+  alias_method :synchronize, :exclusive
 
   # Returns true if the count is currently zero (additional external
   # synchronization is usually required if other threads can modify the

data/spec/selectable/channel_spec.rb

@@ -0,0 +1,45 @@
+require 'concurrent/selectable/channel'
+
+SChannel = Concurrent::Selectable::Channel
+
+describe SChannel do
+  before :each do
+    @channel = SChannel.new
+  end
+
+  it "should be convertable to an IO object" do
+    @channel.to_io.should be_an_instance_of(IO)
+  end
+
+  it "should allow values to be written with << and received with receive" do
+    @channel << :blah
+    t = Thread.new { sleep 2 ; @channel << nil }
+    @channel.receive.should == :blah
+  end
+
+  it "should allow values to be written with put and received with get" do
+    @channel.put :blah
+    t = Thread.new { sleep 2 ; @channel.put nil }
+    @channel.get.should == :blah
+  end
+
+  it "should block while a value is not available" do
+    t = Thread.new { sleep 2 ; @channel << :foo }
+    @channel.receive.should == :foo
+  end
+
+  it "should not be readable when empty empty" do
+    IO.select([@channel], nil, nil, 0).should be_nil
+  end
+
+  it "should be readable while it has values" do
+    @channel << :blah
+    IO.select([@channel], nil, nil, 0).should == [[@channel], [], []]
+  end
+
+  it "should not be readable after it has been emptied" do
+    @channel << :blah
+    @channel.receive
+    IO.select([@channel], nil, nil, 0).should be_nil
+  end
+end

data/spec/selectable/latch_spec.rb

@@ -0,0 +1,28 @@
+require 'concurrent/selectable/latch'
+
+Latch = Concurrent::Selectable::Latch
+
+describe Latch do
+  before :each do
+    @latch = Latch.new
+  end
+
+  it "should be convertable to an IO object" do
+    @latch.to_io.should be_an_instance_of(IO)
+  end
+
+  it "should not be readable when it is not set" do
+    IO.select([@latch], nil, nil, 0).should be_nil
+  end
+
+  it "should be readable when it is set" do
+    @latch.set
+    IO.select([@latch], nil, nil, 0).should == [[@latch], [], []]
+  end
+
+  it "should not be readable after it is reset" do
+    @latch.set
+    @latch.reset
+    IO.select([@latch], nil, nil, 0).should be_nil
+  end
+end

data/spec/selectable/semaphore_spec.rb

@@ -0,0 +1,28 @@
+require 'concurrent/selectable/semaphore'
+
+CSemaphore = Concurrent::Selectable::Semaphore
+
+describe CSemaphore do
+  before :each do
+    @semaphore = CSemaphore.new
+  end
+
+  it "should be convertable to an IO object" do
+    @semaphore.to_io.should be_an_instance_of(IO)
+  end
+
+  it "should not be readable when it has a zero count" do
+    IO.select([@semaphore], nil, nil, 0).should be_nil
+  end
+
+  it "should be readable after it has been incremented" do
+    @semaphore.put
+    IO.select([@semaphore], nil, nil, 0).should == [[@semaphore], [], []]
+  end
+
+  it "should not be readable after it has been decremented again" do
+    @semaphore.put
+    @semaphore.get
+    IO.select([@semaphore], nil, nil, 0).should be_nil
+  end
+end

metadata

@@ -1,11 +1,11 @@
 --- !ruby/object:Gem::Specification 
-rubygems_version: 0.8.11
+rubygems_version: 0.9.4
 specification_version: 1
 name: concurrent-selectable
 version: !ruby/object:Gem::Version 
-  version: "0.1"
-date: 2008-01-27 00:00:00 -05:00
-summary: Synchronization primitives with selectable IO channels
+  version: 0.1.1
+date: 2008-06-03 00:00:00 -04:00
+summary: Synchronization primitives for event-driven IO
 require_paths: 
 - lib
 email: 
@@ -25,21 +25,20 @@ required_ruby_version: !ruby/object:Gem::Version::Requirement
 platform: ruby
 signing_key: 
 cert_chain: 
+post_install_message: 
 authors: 
 - MenTaLguY <mental@rydia.net>
 files: 
-- Rakefile
-- test/test_latch.rb
-- test/test_all.rb
-- test/test_semaphore.rb
-- test/test_channel.rb
+- spec/selectable/channel_spec.rb
+- spec/selectable/latch_spec.rb
+- spec/selectable/semaphore_spec.rb
 - lib/concurrent/selectable.rb
-- lib/concurrent/selectable/latch.rb
+- lib/concurrent/selectable/channel.rb
 - lib/concurrent/selectable/common.rb
+- lib/concurrent/selectable/latch.rb
 - lib/concurrent/selectable/semaphore.rb
-- lib/concurrent/selectable/channel.rb
-test_files: 
-- test/test_all.rb
+test_files: []
+
 rdoc_options: []
 
 extra_rdoc_files: []

data/Rakefile

@@ -1,42 +0,0 @@
-require 'rake'
-require 'rake/testtask'
-require 'rake/rdoctask'
-require 'rake/gempackagetask'
-require 'rake/clean'
-
-GEM_VERSION = "0.1"
-
-Rake::RDocTask.new do |task|
-  task.rdoc_files.add [ 'lib/**/*.rb' ]
-end
-
-task :clobber => [ :clean ]
-
-Rake::TestTask.new do |task|
-  task.ruby_opts << '-rrubygems'
-  task.libs << 'lib'
-  task.libs << 'test'
-  task.test_files = [ "test/test_all.rb" ]
-  task.verbose = true
-end
-
-gemspec = Gem::Specification.new do |gemspec|
-  gemspec.name = "concurrent-selectable"
-  gemspec.version = GEM_VERSION
-  gemspec.author = "MenTaLguY <mental@rydia.net>"
-  gemspec.summary = "Synchronization primitives with selectable IO channels"
-  gemspec.test_file = 'test/test_all.rb'
-  gemspec.files = FileList[ 'Rakefile', 'test/*.rb', 'lib/**/*.rb' ]
-  gemspec.require_paths = [ 'lib' ]
-  gemspec.has_rdoc = true
-  gemspec.platform = Gem::Platform::RUBY
-end
-
-task :package => [ :clean, :test ]
-Rake::GemPackageTask.new( gemspec ) do |task|
-  task.gem_spec = gemspec
-  task.need_tar = true
-end
-
-task :default => [ :clean, :test ]
-

data/test/test_all.rb

@@ -1,3 +0,0 @@
-require 'test_channel.rb'
-require 'test_latch.rb'
-require 'test_semaphore.rb'

data/test/test_channel.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-require 'concurrent/selectable/channel'
-
-SChannel = Concurrent::Selectable::Channel
-
-class TestChannel < Test::Unit::TestCase
-  def test_to_io
-    channel = SChannel.new
-    assert_instance_of IO, channel.to_io
-  end
-
-  def test_select
-    channel = SChannel.new
-    ready = IO.select([channel], nil, nil, 0.01)
-    assert !ready
-    channel.put :blah
-    ready = IO.select([channel], nil, nil, 0.01)
-    assert ready
-    channel.get
-    ready = IO.select([channel], nil, nil, 0.01)
-    assert !ready
-  end
-end

data/test/test_latch.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-require 'concurrent/selectable/latch'
-
-Latch = Concurrent::Selectable::Latch
-
-class TestLatch < Test::Unit::TestCase
-  def test_to_io
-    latch = Latch.new
-    assert_instance_of IO, latch.to_io
-  end
-
-  def test_select
-    latch = Latch.new
-    ready = IO.select([latch], nil, nil, 0.01)
-    assert !ready
-    latch.set
-    ready = IO.select([latch], nil, nil, 0.01)
-    assert ready
-    latch.reset
-    ready = IO.select([latch], nil, nil, 0.01)
-    assert !ready
-  end
-end

data/test/test_semaphore.rb

@@ -1,23 +0,0 @@
-require 'test/unit'
-require 'concurrent/selectable/semaphore'
-
-Semaphore = Concurrent::Selectable::Semaphore
-
-class TestSemaphore < Test::Unit::TestCase
-  def test_to_io
-    semaphore = Semaphore.new
-    assert_instance_of IO, semaphore.to_io
-  end
-
-  def test_select
-    semaphore = Semaphore.new
-    ready = IO.select([semaphore], nil, nil, 0.01)
-    assert !ready
-    semaphore.put
-    ready = IO.select([semaphore], nil, nil, 0.01)
-    assert ready
-    semaphore.get
-    ready = IO.select([semaphore], nil, nil, 0.01)
-    assert !ready
-  end
-end