quack_concurrency 0.4.1 → 0.5.0

data/spec/semaphore_spec.rb

@@ -1,277 +1,244 @@
-require 'quack_concurrency'
+#require 'quack_concurrency'
 
-RSpec.describe QuackConcurrency::Semaphore do
+#RSpec.describe QuackConcurrency::Semaphore do
   
-  describe "::new" do
+  #describe "#release" do
   
-    context "when called without a 'duck_types' argument" do
-      it "should create a new QuackConcurrency::Semaphore" do
-        semaphore = QuackConcurrency::Semaphore.new
-        expect(semaphore).to be_a(QuackConcurrency::Semaphore)
-      end
-    end
-    
-    context "when called with 'condition_variable' and 'mutex' duck types" do
-      it "should create a new QuackConcurrency::Semaphore" do
-        duck_types = {condition_variable: Class.new, mutex: Class.new}
-        semaphore = QuackConcurrency::Semaphore.new(duck_types: duck_types)
-        expect(semaphore).to be_a(QuackConcurrency::Semaphore)
-      end
-    end
-    
-    context "when called with only 'condition_variable' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {condition_variable: Class.new}
-        expect{ QuackConcurrency::Semaphore.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-    context "when called with only 'mutex' duck type" do
-      it "should raise ArgumentError" do
-        duck_types = {mutex: Class.new}
-        expect{ QuackConcurrency::Semaphore.new(duck_types: duck_types) }.to raise_error(ArgumentError)
-      end
-    end
-    
-  end
-  
-  describe "#release" do
-  
-    context "when called for the first time with many permits available" do
-      it "should not raise error" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
+    #context "when called for the first time with many permits available" do
+      #it "should not raise error" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
         
-        expect{ semaphore.release }.not_to raise_error
-      end
-    end
-    
-    context "when called a second time with one permit available" do
-      it "should not raise error" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        semaphore.release
-        expect{ semaphore.release }.not_to raise_error
-      end
-    end
-  
-  end
-  
-  describe "#release, #reacquire" do
-    
-    context "when #release called with no permits available" do
-      it "should wait until #reacquire is called" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        semaphore.release
-        semaphore.release
-        thread = Thread.new do
-          sleep 1
-          semaphore.reacquire
-        end
-        start_time = Time.now
-        semaphore.release
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be > 0.5
-      end
-    end
-    
-    context "when #reacquire called when all permits are available" do
-      it "should raise QuackConcurrency::Semaphore::Error" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect{ semaphore.reacquire }.to raise_error(QuackConcurrency::Semaphore::Error)
-      end
-    end
-    
-  end
-  
-  describe "#release, #reacquire, #permit_available?, #permits_available" do
-  
-    context "#permit_available? and #permits_available" do
-      it "should work as expected" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permit_available?).to eql true
-        expect(semaphore.permits_available).to eql 2
-        semaphore.release
-        expect(semaphore.permit_available?).to eql true
-        expect(semaphore.permits_available).to eql 1
-        semaphore.release
-        expect(semaphore.permit_available?).to eql false
-        expect(semaphore.permits_available).to eql 0
-        semaphore.reacquire
-        expect(semaphore.permit_available?).to eql true
-        expect(semaphore.permits_available).to eql 1
-        semaphore.reacquire
-        expect(semaphore.permit_available?).to eql true
-        expect(semaphore.permits_available).to eql 2
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count, #permits_available" do
-  
-    context "when #set_permit_count is called with more permits then currently exist" do
-      it "should add permits" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.set_permit_count(3)
-        expect(semaphore.permits_available).to eql 3
-      end
-    end
-    
-    context "when #set_permit_count is called with less permits then currently exist" do
-      it "should remove permits" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.set_permit_count(1)
-        expect(semaphore.permits_available).to eql 1
-      end
-    end
-  
-  end
-  
-  describe "#set_permit_count, #permits_available, #release" do
-    
-    context "when #set_permit_count is called with less permits then currently available" do
-      it "should raise QuackConcurrency::Semaphore::Error" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.release
-        semaphore.release
-        expect{ semaphore.set_permit_count(1) }.to raise_error(QuackConcurrency::Semaphore::Error)
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count, #release" do
-  
-    context "when #set_permit_count is called with more permits when one thread is waiting on #release" do
-      it "should resume the thread" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        semaphore.release
-        semaphore.release
-        thread = Thread.new do
-          sleep 1
-          semaphore.set_permit_count(3)
-        end
-        start_time = Time.now
-        semaphore.release
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be > 0.5
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count!, #permits_available" do
-  
-    context "when #set_permit_count! is called with more permits then currently exist" do
-      it "should add permits" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.set_permit_count!(3)
-        expect(semaphore.permits_available).to eql 3
-      end
-    end
-    
-    context "when #set_permit_count! is called with less permits then currently exist" do
-      it "should remove permits" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.set_permit_count!(1)
-        expect(semaphore.permits_available).to eql 1
-      end
-    end
-  
-  end
-  
-  describe "#set_permit_count!, #permits_available, #release, #reacquire" do
-    
-    context "when #set_permit_count! is called with less permits then currently available" do
-      it "should force new permit count" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        expect(semaphore.permits_available).to eql 2
-        semaphore.release
-        semaphore.release
-        semaphore.set_permit_count!(1)
-        expect(semaphore.permit_available?).to eql false
-        semaphore.reacquire
-        expect(semaphore.permit_available?).to eql false
-        semaphore.reacquire
-        expect(semaphore.permit_available?).to eql true
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count!, #release" do
-  
-    context "when #set_permit_count! is called with more permits when one thread is waiting on #release" do
-      it "should resume the thread" do
-        semaphore = QuackConcurrency::Semaphore.new(2)
-        semaphore.release
-        semaphore.release
-        thread = Thread.new do
-          sleep 1
-          semaphore.set_permit_count(3)
-        end
-        start_time = Time.now
-        semaphore.release
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be > 0.5
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count!, #release, #permit_available?" do
-  
-    context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then called again to add 1 permit" do
-      it "should not have any permits available" do
-        semaphore = QuackConcurrency::Semaphore.new(3)
-        semaphore.release
-        semaphore.release
-        expect(semaphore.permit_available?).to eql true
-        semaphore.set_permit_count!(1)
-        expect(semaphore.permit_available?).to eql false
-        semaphore.set_permit_count!(2)
-        expect(semaphore.permit_available?).to eql false
-      end
-    end
-    
-  end
-  
-  describe "#set_permit_count!, #release, #reacquire" do
-  
-    context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then a thread starts waiting for #release, then #set_permit_count! is called again to add 1 permit" do
-      it "thread should wait for #reacquire to be called" do
-        semaphore = QuackConcurrency::Semaphore.new(3)
-        semaphore.release
-        semaphore.release
-        semaphore.release
-        semaphore.set_permit_count!(1)
-        thread = Thread.new do
-          sleep 1
-          semaphore.set_permit_count!(2)
-          sleep 1
-          semaphore.reacquire
-          sleep 1
-          semaphore.reacquire
-        end
-        start_time = Time.now
-        semaphore.release
-        end_time = Time.now
-        duration = end_time - start_time
-        thread.join
-        expect(duration).to be_between(2.5, 3.5)
-      end
-    end
-    
-  end
+        #expect{ semaphore.release }.not_to raise_error
+      #end
+    #end
+    
+    #context "when called a second time with one permit available" do
+      #it "should not raise error" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #semaphore.release
+        #expect{ semaphore.release }.not_to raise_error
+      #end
+    #end
+  
+  #end
+  
+  #describe "#release, #reacquire" do
+    
+    #context "when #release called with no permits available" do
+      #it "should wait until #reacquire is called" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #semaphore.release
+        #semaphore.release
+        #thread = Thread.new do
+          #sleep 1
+          #semaphore.reacquire
+        #end
+        #start_time = Time.now
+        #semaphore.release
+        #end_time = Time.now
+        #duration = end_time - start_time
+        #thread.join
+        #expect(duration).to be > 0.5
+      #end
+    #end
+    
+    #context "when #reacquire called when all permits are available" do
+      #it "should raise QuackConcurrency::Semaphore::Error" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect{ semaphore.reacquire }.to raise_error(QuackConcurrency::Semaphore::Error)
+      #end
+    #end
+    
+  #end
+  
+  #describe "#release, #reacquire, #permit_available?, #permits_available" do
+  
+    #context "#permit_available? and #permits_available" do
+      #it "should work as expected" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permit_available?).to eql true
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.release
+        #expect(semaphore.permit_available?).to eql true
+        #expect(semaphore.permits_available).to eql 1
+        #semaphore.release
+        #expect(semaphore.permit_available?).to eql false
+        #expect(semaphore.permits_available).to eql 0
+        #semaphore.reacquire
+        #expect(semaphore.permit_available?).to eql true
+        #expect(semaphore.permits_available).to eql 1
+        #semaphore.reacquire
+        #expect(semaphore.permit_available?).to eql true
+        #expect(semaphore.permits_available).to eql 2
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count, #permits_available" do
+  
+    #context "when #set_permit_count is called with more permits then currently exist" do
+      #it "should add permits" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.set_permit_count(3)
+        #expect(semaphore.permits_available).to eql 3
+      #end
+    #end
+    
+    #context "when #set_permit_count is called with less permits then currently exist" do
+      #it "should remove permits" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.set_permit_count(1)
+        #expect(semaphore.permits_available).to eql 1
+      #end
+    #end
+  
+  #end
+  
+  #describe "#set_permit_count, #permits_available, #release" do
+    
+    #context "when #set_permit_count is called with less permits then currently available" do
+      #it "should raise QuackConcurrency::Semaphore::Error" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.release
+        #semaphore.release
+        #expect{ semaphore.set_permit_count(1) }.to raise_error(QuackConcurrency::Semaphore::Error)
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count, #release" do
+  
+    #context "when #set_permit_count is called with more permits when one thread is waiting on #release" do
+      #it "should resume the thread" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #semaphore.release
+        #semaphore.release
+        #thread = Thread.new do
+          #sleep 1
+          #semaphore.set_permit_count(3)
+        #end
+        #start_time = Time.now
+        #semaphore.release
+        #end_time = Time.now
+        #duration = end_time - start_time
+        #thread.join
+        #expect(duration).to be > 0.5
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count!, #permits_available" do
+  
+    #context "when #set_permit_count! is called with more permits then currently exist" do
+      #it "should add permits" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.set_permit_count!(3)
+        #expect(semaphore.permits_available).to eql 3
+      #end
+    #end
+    
+    #context "when #set_permit_count! is called with less permits then currently exist" do
+      #it "should remove permits" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.set_permit_count!(1)
+        #expect(semaphore.permits_available).to eql 1
+      #end
+    #end
+  
+  #end
+  
+  #describe "#set_permit_count!, #permits_available, #release, #reacquire" do
+    
+    #context "when #set_permit_count! is called with less permits then currently available" do
+      #it "should force new permit count" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #expect(semaphore.permits_available).to eql 2
+        #semaphore.release
+        #semaphore.release
+        #semaphore.set_permit_count!(1)
+        #expect(semaphore.permit_available?).to eql false
+        #semaphore.reacquire
+        #expect(semaphore.permit_available?).to eql false
+        #semaphore.reacquire
+        #expect(semaphore.permit_available?).to eql true
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count!, #release" do
+  
+    #context "when #set_permit_count! is called with more permits when one thread is waiting on #release" do
+      #it "should resume the thread" do
+        #semaphore = QuackConcurrency::Semaphore.new(2)
+        #semaphore.release
+        #semaphore.release
+        #thread = Thread.new do
+          #sleep 1
+          #semaphore.set_permit_count(3)
+        #end
+        #start_time = Time.now
+        #semaphore.release
+        #end_time = Time.now
+        #duration = end_time - start_time
+        #thread.join
+        #expect(duration).to be > 0.5
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count!, #release, #permit_available?" do
+  
+    #context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then called again to add 1 permit" do
+      #it "should not have any permits available" do
+        #semaphore = QuackConcurrency::Semaphore.new(3)
+        #semaphore.release
+        #semaphore.release
+        #expect(semaphore.permit_available?).to eql true
+        #semaphore.set_permit_count!(1)
+        #expect(semaphore.permit_available?).to eql false
+        #semaphore.set_permit_count!(2)
+        #expect(semaphore.permit_available?).to eql false
+      #end
+    #end
+    
+  #end
+  
+  #describe "#set_permit_count!, #release, #reacquire" do
+  
+    #context "when semaphore has no permits available, them #set_permit_count! is called to remove 2 permits, then a thread starts waiting for #release, then #set_permit_count! is called again to add 1 permit" do
+      #it "thread should wait for #reacquire to be called" do
+        #semaphore = QuackConcurrency::Semaphore.new(3)
+        #semaphore.release
+        #semaphore.release
+        #semaphore.release
+        #semaphore.set_permit_count!(1)
+        #thread = Thread.new do
+          #sleep 1
+          #semaphore.set_permit_count!(2)
+          #sleep 1
+          #semaphore.reacquire
+          #sleep 1
+          #semaphore.reacquire
+        #end
+        #start_time = Time.now
+        #semaphore.release
+        #end_time = Time.now
+        #duration = end_time - start_time
+        #thread.join
+        #expect(duration).to be_between(2.5, 3.5)
+      #end
+    #end
+    
+  #end
 
-end
+#end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: quack_concurrency
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Rob Fors
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-04-19 00:00:00.000000000 Z
+date: 2018-05-31 00:00:00.000000000 Z
 dependencies: []
 description: Offers concurrency tools that could also be found in the 'Concurrent
   Ruby'. However, all these tools will also accept core class duck types to build
@@ -22,19 +22,22 @@ files:
 - README.md
 - Rakefile
 - lib/quack_concurrency.rb
-- lib/quack_concurrency/concurrency_tool.rb
+- lib/quack_concurrency/condition_variable.rb
 - lib/quack_concurrency/error.rb
 - lib/quack_concurrency/future.rb
 - lib/quack_concurrency/future/canceled.rb
 - lib/quack_concurrency/future/complete.rb
-- lib/quack_concurrency/name.rb
+- lib/quack_concurrency/mutex.rb
 - lib/quack_concurrency/queue.rb
 - lib/quack_concurrency/queue/error.rb
 - lib/quack_concurrency/reentrant_mutex.rb
 - lib/quack_concurrency/reentrant_mutex/error.rb
 - lib/quack_concurrency/semaphore.rb
 - lib/quack_concurrency/semaphore/error.rb
+- lib/quack_concurrency/uninterruptible_condition_variable.rb
+- lib/quack_concurrency/uninterruptible_sleeper.rb
 - lib/quack_concurrency/waiter.rb
+- lib/quack_concurrency/yielder.rb
 - spec/future_spec.rb
 - spec/queue_spec.rb
 - spec/reentrant_mutex_spec.rb

data/lib/quack_concurrency/concurrency_tool.rb

@@ -1,28 +0,0 @@
-module QuackConcurrency
-  
-  # @api private
-  class ConcurrencyTool
-    
-    def setup_duck_types(supplied_classes)
-      resultant_classes = {}
-      required_classes = [:condition_variable, :mutex]
-      required_classes = required_classes.map { |name| Name.new(name.to_s) }
-      if supplied_classes
-        raise ArgumentError, "'supplied_classes' must be Hash" unless supplied_classes.is_a?(Hash)
-        supplied_classes = supplied_classes.map { |k, v| [Name.new(k.to_s), v] }.to_h
-        required_classes.each do |class_name|
-          unless supplied_classes[class_name]
-            raise ArgumentError, "missing duck type: #{class_name.camel_case(:upper)}"
-          end
-          resultant_classes[class_name.snake_case.to_sym] = supplied_classes[class_name]
-        end
-      else
-        required_classes.each do |class_name|
-          resultant_classes[class_name.snake_case.to_sym] = Object.const_get(class_name.camel_case(:upper))
-        end
-      end
-      resultant_classes
-    end
-    
-  end
-end

data/lib/quack_concurrency/name.rb

@@ -1,33 +0,0 @@
-module QuackConcurrency
-  
-  # @api private
-  class Name < String
-    
-    def initialize(*args)
-      super
-      # set all names to a default case
-      # if we create two of the same name with different cases they will now be equal
-      replace(snake_case)
-    end
-    
-    def camel_case(first_letter = :upper)
-      case first_letter
-      when :upper
-        self.split('_').collect(&:capitalize).join
-      when :lower
-        self.camelcase(:upper)[0].downcase + self.camelcase(:upper)[1..-1]
-      else
-        raise ArgumentError, 'invalid option, use either :upper or :lower'
-      end
-    end
-    
-    def snake_case
-      self.gsub(/::/, '/').
-      gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
-      gsub(/([a-z\d])([A-Z])/,'\1_\2').
-      tr("- ", "_").
-      downcase
-    end
-    
-  end
-end