concurrent-ruby 0.1.1.pre.3 → 0.1.1.pre.4

data/spec/concurrent/utilities_spec.rb

@@ -1,74 +1,74 @@
-require 'spec_helper'
-require 'thread'
-
-describe 'utilities' do
-
-  context '#atomic' do
-
-    it 'calls the block' do
-      @expected = false
-      atomic{ @expected = true }
-      @expected.should be_true
-    end
-
-    it 'passes all arguments to the block' do
-      @expected = nil
-      atomic(1, 2, 3, 4) do |a, b, c, d|
-        @expected = [a, b, c, d]
-      end
-      @expected.should eq [1, 2, 3, 4]
-    end
-
-    it 'returns the result of the block' do
-      expected = atomic{ 'foo' }
-      expected.should eq 'foo'
-    end
-
-    it 'raises an exception if no block is given' do
-      lambda {
-        atomic()
-      }.should raise_error(ArgumentError)
-    end
-
-    it 'creates a new Fiber' do
-      fiber = Fiber.new{ 'foo' }
-      Fiber.should_receive(:new).with(no_args()).and_return(fiber)
-      atomic{ 'foo' }
-    end
-
-    it 'immediately runs the Fiber' do
-      fiber = Fiber.new{ 'foo' }
-      Fiber.stub(:new).with(no_args()).and_return(fiber)
-      fiber.should_receive(:resume).with(no_args())
-      atomic{ 'foo' }
-    end
-  end
-
-  context Mutex do
-
-     context '#sync_with_timeout' do
-
-       it 'returns the result of the block if a lock is obtained before timeout' do
-         mutex = Mutex.new
-         result = mutex.sync_with_timeout(30){ 42 }
-         result.should eq 42
-       end
-
-       it 'raises Timeout::Error if the timeout is exceeded' do
-         mutex = Mutex.new
-         thread = Thread.new{ mutex.synchronize{ sleep(30) } }
-         sleep(0.1)
-         lambda {
-           mutex.sync_and_wait(1)
-         }.should raise_error(NoMethodError)
-         Thread.kill(thread)
-       end
-
-       it 'raises an exception if no block given' do
-         lambda {
-           Mutex.new.sync_with_timeout()
-         }.should raise_error(ArgumentError)
-       end
-     end
-  end
-end
+require 'spec_helper'
+require 'thread'
+
+describe 'utilities' do
+
+  context '#atomic' do
+
+    it 'calls the block' do
+      @expected = false
+      atomic{ @expected = true }
+      @expected.should be_true
+    end
+
+    it 'passes all arguments to the block' do
+      @expected = nil
+      atomic(1, 2, 3, 4) do |a, b, c, d|
+        @expected = [a, b, c, d]
+      end
+      @expected.should eq [1, 2, 3, 4]
+    end
+
+    it 'returns the result of the block' do
+      expected = atomic{ 'foo' }
+      expected.should eq 'foo'
+    end
+
+    it 'raises an exception if no block is given' do
+      lambda {
+        atomic()
+      }.should raise_error(ArgumentError)
+    end
+
+    it 'creates a new Fiber' do
+      fiber = Fiber.new{ 'foo' }
+      Fiber.should_receive(:new).with(no_args()).and_return(fiber)
+      atomic{ 'foo' }
+    end
+
+    it 'immediately runs the Fiber' do
+      fiber = Fiber.new{ 'foo' }
+      Fiber.stub(:new).with(no_args()).and_return(fiber)
+      fiber.should_receive(:resume).with(no_args())
+      atomic{ 'foo' }
+    end
+  end
+
+  context Mutex do
+
+     context '#sync_with_timeout' do
+
+       it 'returns the result of the block if a lock is obtained before timeout' do
+         mutex = Mutex.new
+         result = mutex.sync_with_timeout(30){ 42 }
+         result.should eq 42
+       end
+
+       it 'raises Timeout::Error if the timeout is exceeded' do
+         mutex = Mutex.new
+         thread = Thread.new{ mutex.synchronize{ sleep(30) } }
+         sleep(0.1)
+         lambda {
+           mutex.sync_and_wait(1)
+         }.should raise_error(NoMethodError)
+         Thread.kill(thread)
+       end
+
+       it 'raises an exception if no block given' do
+         lambda {
+           Mutex.new.sync_with_timeout()
+         }.should raise_error(ArgumentError)
+       end
+     end
+  end
+end

data/spec/spec_helper.rb

@@ -1,30 +1,44 @@
-require 'simplecov'
-SimpleCov.start do
-  project_name 'concurrent-ruby'
-  add_filter '/md/'
-  add_filter '/pkg/'
-  add_filter '/spec/'
-  add_filter '/tasks/'
-end
-
-require 'eventmachine'
-
-require 'concurrent'
-require 'concurrent/functions'
-
-# import all the support files
-Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
-
-RSpec.configure do |config|
-  config.order = 'random'
-
-  config.before(:suite) do
-  end
-
-  config.before(:each) do
-  end
-
-  config.after(:each) do
-  end
-
-end
+require 'simplecov'
+SimpleCov.start do
+  project_name 'concurrent-ruby'
+  add_filter '/md/'
+  add_filter '/pkg/'
+  add_filter '/spec/'
+  add_filter '/tasks/'
+end
+
+require 'eventmachine'
+
+require 'concurrent'
+require 'concurrent/functions'
+
+require 'rbconfig'
+
+def mri?
+  RbConfig::CONFIG['ruby_install_name'] =~ /^ruby$/i
+end
+
+def jruby?
+  RbConfig::CONFIG['ruby_install_name'] =~ /^jruby$/i
+end
+
+def rbx?
+  RbConfig::CONFIG['ruby_install_name'] =~ /^rbx$/i
+end
+
+# import all the support files
+Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require File.expand_path(f) }
+
+RSpec.configure do |config|
+  config.order = 'random'
+
+  config.before(:suite) do
+  end
+
+  config.before(:each) do
+  end
+
+  config.after(:each) do
+  end
+
+end

metadata

@@ -1,20 +1,18 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby
 version: !ruby/object:Gem::Version
-  version: 0.1.1.pre.3
-  prerelease: 6
+  version: 0.1.1.pre.4
 platform: ruby
 authors:
 - Jerry D'Antonio
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-12 00:00:00.000000000 Z
+date: 2013-08-13 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: functional-ruby
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -22,7 +20,6 @@ dependencies:
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
     - - ~>
       - !ruby/object:Gem::Version
@@ -30,23 +27,19 @@ dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
-    none: false
     requirements:
-    - - ! '>='
+    - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: ! '    A gem for adding Erlang, Clojure, and Go inspired concurrent programming
-  tools to Ruby.
-
-'
+description: |2
+      A gem for adding Erlang, Clojure, and Go inspired concurrent programming tools to Ruby.
 email: jerry.dantonio@gmail.com
 executables: []
 extensions: []
@@ -73,7 +66,6 @@ files:
 - lib/concurrent/reactor/drb_async_demux.rb
 - lib/concurrent/reactor/tcp_sync_demux.rb
 - lib/concurrent/reactor.rb
-- lib/concurrent/smart_mutex.rb
 - lib/concurrent/thread_pool.rb
 - lib/concurrent/utilities.rb
 - lib/concurrent/version.rb
@@ -105,34 +97,32 @@ files:
 - spec/concurrent/reactor/drb_async_demux_spec.rb
 - spec/concurrent/reactor/tcp_sync_demux_spec.rb
 - spec/concurrent/reactor_spec.rb
-- spec/concurrent/smart_mutex_spec.rb
 - spec/concurrent/thread_pool_shared.rb
 - spec/concurrent/utilities_spec.rb
 - spec/spec_helper.rb
 homepage: https://github.com/jdantonio/concurrent-ruby/
 licenses:
 - MIT
+metadata: {}
 post_install_message: 
 rdoc_options: []
 require_paths:
 - lib
 required_ruby_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>='
+  - - '>='
     - !ruby/object:Gem::Version
       version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
-  none: false
   requirements:
-  - - ! '>'
+  - - '>'
     - !ruby/object:Gem::Version
       version: 1.3.1
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 2.0.6
 signing_key: 
-specification_version: 3
+specification_version: 4
 summary: Erlang, Clojure, and Go inspired concurrent programming tools for Ruby.
 test_files:
 - spec/concurrent/agent_spec.rb
@@ -152,7 +142,6 @@ test_files:
 - spec/concurrent/reactor/drb_async_demux_spec.rb
 - spec/concurrent/reactor/tcp_sync_demux_spec.rb
 - spec/concurrent/reactor_spec.rb
-- spec/concurrent/smart_mutex_spec.rb
 - spec/concurrent/thread_pool_shared.rb
 - spec/concurrent/utilities_spec.rb
 - spec/spec_helper.rb

data/lib/concurrent/smart_mutex.rb

@@ -1,66 +0,0 @@
-require 'thread'
-require 'concurrent/utilities'
-
-module Concurrent
-
-  class SmartMutex
-
-    def initialize
-      @mutex = Mutex.new
-    end
-
-    def alone?
-      Thread.list.length <= 1
-    end
-
-    def lock
-      atomic do
-        @mutex.lock unless alone?
-        self
-      end
-    end
-
-    def locked?
-      atomic do
-        if alone?
-          false
-        else
-          @mutex.locked?
-        end
-      end
-    end
-
-    def sleep(timeout)
-      if alone?
-        Kernel.sleep(timeout)
-      else
-        @mutex.sleep(timeout)
-      end
-    end
-
-    def synchronize(&block)
-      if alone?
-        yield
-      else
-        @mutex.synchronize(&block)
-      end
-    end
-
-    def try_lock
-      atomic do
-        if alone?
-          true
-        else
-          @mutex.try_lock
-        end
-      end
-    end
-
-    def unlock
-      atomic do
-        @mutex.unlock unless alone?
-        self
-      end
-    end
-  end
-end

data/spec/concurrent/smart_mutex_spec.rb

@@ -1,234 +0,0 @@
-require 'spec_helper'
-
-module Concurrent
-
-  describe SmartMutex do
-
-    subject{ SmartMutex.new }
-
-    def fly_solo
-      Thread.stub(:list).and_return(Array.new)
-    end
-
-    def run_with_the_pack
-      Thread.stub(:list).and_return([1,2,3,4])
-    end
-
-    context '#initialize' do
-
-      it 'creates a new mutex' do
-        Mutex.should_receive(:new).with(no_args())
-        SmartMutex.new
-      end
-    end
-
-    context '#alone?' do
-
-      it 'returns true when there is only one thread' do
-        fly_solo
-        subject.alone?.should be_true
-      end
-
-      it 'returns false when there is more than one thread' do
-        run_with_the_pack
-        subject.alone?.should be_false
-      end
-    end
-
-    context '#lock' do
-
-      it 'does not lock when there is only one thread' do
-        fly_solo
-
-        mutex = Mutex.new
-        mutex.should_not_receive(:lock)
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        subject.lock
-      end
-
-      it 'locks when not locked and there is more than one thread' do
-        run_with_the_pack
-
-        mutex = Mutex.new
-        mutex.should_receive(:lock)
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        subject.lock
-      end
-
-      it 'raises an exception when locked and there is more than one thread' do
-        run_with_the_pack
-        subject.lock
-        lambda {
-          subject.lock
-        }.should raise_error(ThreadError)
-      end
-
-      it 'does not raise an exception when lock called twice and there is only one thread' do
-        fly_solo
-        subject.lock
-        lambda {
-          subject.lock
-        }.should_not raise_error
-      end
-
-      it 'returns self' do
-        fly_solo
-        mutex = SmartMutex.new
-        mutex.lock.should eq mutex
-
-        run_with_the_pack
-        mutex.lock.should eq mutex
-      end
-    end
-
-    context '#locked?' do
-
-      it 'returns false when there is only one thread' do
-        fly_solo
-        subject.should_not be_locked
-      end
-
-      it 'returns true when locked and there is more than one thread' do
-        run_with_the_pack
-        subject.lock
-        subject.should be_locked
-      end
-
-      it 'returns false when not locked and there is more than one thread' do
-        run_with_the_pack
-        subject.should_not be_locked
-      end
-    end
-
-    context '#sleep' do
-
-      it 'sleeps when there is only one thread' do
-        fly_solo
-        Kernel.should_receive(:sleep).with(0.1).and_return(0.1)
-        subject.sleep(0.1)
-      end
-
-      it 'sleeps when locked and there is more than one thread' do
-        mutex = Mutex.new
-        mutex.should_receive(:sleep).with(0.1).and_return(0.1)
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        run_with_the_pack
-        subject.lock
-        subject.sleep(0.1)
-      end
-
-      it 'raises an exception when not locked and there is more than one thread' do
-        run_with_the_pack
-        lambda {
-          subject.sleep(0.1)
-        }.should raise_error(ThreadError)
-      end
-
-      it 'returns the number of seconds slept' do
-        fly_solo
-        subject.sleep(1).should eq 1
-
-        run_with_the_pack
-        subject.lock
-        subject.sleep(1).should eq 1
-      end
-    end
-
-    context '#synchronize' do
-
-      it 'yields to the block when there is only one thread' do
-        fly_solo
-        @expected = false
-        subject.synchronize{ @expected = true }
-        @expected.should be_true
-      end
-
-      it 'locks when there is more than one thread' do
-        mutex = Mutex.new
-        mutex.should_receive(:synchronize).with(no_args())
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        run_with_the_pack
-        subject.synchronize{ nil }
-      end
-
-      it 'yields to the block when there is more than one thread' do
-        run_with_the_pack
-        @expected = false
-        subject.synchronize{ @expected = true }
-        @expected.should be_true
-      end
-
-      it 'returns the result of the block' do
-        fly_solo
-        subject.synchronize{ 42 }.should eq 42
-
-        run_with_the_pack
-        subject.synchronize{ 42 }.should eq 42
-      end
-    end
-
-    context '#try_lock' do
-
-      it 'returns true when there is only one thread' do
-        fly_solo
-        subject.try_lock.should be_true
-      end
-
-      it 'returns true when the lock is obtained and there is more than one thread' do
-        run_with_the_pack
-        subject.try_lock.should be_true
-      end
-
-      it 'returns false when the lock is not obtained and there is more than one thread' do
-        run_with_the_pack
-        subject.lock
-        subject.try_lock.should be_false
-      end
-    end
-
-    context '#unlock' do
-
-      it 'does not unlock when there is only one thread' do
-        fly_solo
-
-        mutex = Mutex.new
-        mutex.should_not_receive(:unlock)
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        subject.unlock
-      end
-
-      it 'unlocks when locked and there is more than one thread' do
-        run_with_the_pack
-
-        mutex = Mutex.new
-        mutex.should_receive(:unlock)
-        Mutex.should_receive(:new).with(no_args()).and_return(mutex)
-
-        subject.lock
-        subject.unlock
-      end
-
-      it 'raises an exception when not locked and there is more than one thread' do
-        run_with_the_pack
-        lambda {
-          subject.unlock
-        }.should raise_error(ThreadError)
-      end
-
-      it 'returns self' do
-        fly_solo
-        mutex = SmartMutex.new
-        mutex.unlock.should eq mutex
-
-        run_with_the_pack
-        mutex.lock
-        mutex.unlock.should eq mutex
-      end
-    end
-  end
-end