going 0.0.3 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d65446460582cc05ff1e4b2a7f2dd75fa8e2de02
-  data.tar.gz: d3bef60cf07e6f7142194c3a524aa7451e8fc46a
+  metadata.gz: e654db8fb9029e5b32303e284551f9182960c418
+  data.tar.gz: 62605bb00f54efe7dc250850f1341f10991cecb5
 SHA512:
-  metadata.gz: e7ada7d6cfc7e6bbf816e546f84c1c5b42f0901d4d8ac6740dd13219c8c73ebecb7d30eaba45f4a08ff4e194edd12f3856253cb267200983d55a649b1eeb510f
-  data.tar.gz: 5b353932fcd9107fddd2edde8fbcf2b950dbd5cc798100ccb1b4fbd7e2f58acf9ba2b6e6179665082232b46f0b55bc12ea6ed1949badffc501c97926a92d9ef9
+  metadata.gz: ed12b04c91fd266ef44da9ef91b36f62b117d7cb869d3a8af21f831e6dfee4cc2c361aaa6e768d90f264e1cc2c97f3ae256a3445c19a3313d90966384fa16918
+  data.tar.gz: d8a8b37ecc0f747f322ca779e08d59e8683dd62c11f873862ba80d7211de40f9667acfef1310b4206dd20ed1fda8ec5cbf096ac59e4c7ce9ea0f96cce60876c8

data/.travis.yml

@@ -3,7 +3,6 @@ rvm:
   - 2.1.2
   - 2.0.0
   - 1.9.3
-  - jruby-18mode # JRuby in 1.8 mode
-  - jruby-19mode # JRuby in 1.9 mode
-  - rbx-2.2.7
-  - rbx-2.2.6
+  # - jruby-19mode # JRuby in 1.9 mode
+  # - rbx-2.2.7
+  # - rbx-2.2.6

data/lib/going/boolean_attr_reader.rb

@@ -0,0 +1,11 @@
+module Going
+  module BooleanAttrReader
+    def battr_reader(*attrs)
+      attrs.map(&:to_s).each do |attr|
+        define_method(attr + '?') do
+          !!instance_variable_get('@' + attr)
+        end
+      end
+    end
+  end
+end

data/lib/going/channel.rb

@@ -1,24 +1,24 @@
-require 'going'
-
 module Going
   #
   # This class represents message channels of specified capacity.
   # The push operation may be blocked if the capacity is full.
-  # The pop operation may be blocked if no messages have been sent.
+  # The shift operation may be blocked if no messages have been sent.
   #
   class Channel
-    extend Forwardable
+    extend BooleanAttrReader
 
     #
     # Creates a fixed-length channel with a capacity of +capacity+.
     #
     def initialize(capacity = 0)
-      fail ArgumentError, 'channel capacity must be 0 or greater' unless capacity >= 0
+      fail ArgumentError, 'channel capacity must be 0 or greater' if capacity < 0
       @capacity = capacity
+
+      @pushes = []
+      @shifts = []
+
       @closed = false
       @mutex = Mutex.new
-      @push_semaphore = ConditionVariable.new
-      @pop_semaphore = ConditionVariable.new
 
       yield self if block_given?
     end
@@ -31,9 +31,7 @@ module Going
     #
     # Returns whether or not the channel is closed.
     #
-    def closed?
-      @closed
-    end
+    battr_reader :closed
 
     #
     # Closes the channel. Any data in the buffer may still be retrieved.
@@ -41,23 +39,33 @@ module Going
     def close
       synchronize do
         return false if closed?
-        @messages = messages.first(capacity)
-        broadcast_close
+
+        shifts.each(&:close).clear
+        pushes_over_capacity!.each(&:close)
         @closed = true
       end
     end
 
     #
     # Pushes +obj+ to the channel. If the channel is already full, waits
-    # until a thread pops from it.
+    # until a thread shifts from it.
     #
-    def push(obj)
+    def push(obj, &on_complete)
       synchronize do
-        fail 'cannot push to a closed channel' if closed?
-        messages.push obj
-        signal_push
-        wait_for_pop if messages.length > capacity
-        check_for_close
+        push = Push.new(message: obj, select_statement: select_statement, &on_complete)
+        pushes << push
+
+        pair_with_shift push
+
+        select_statement.when_complete(push, pushes, &method(:remove_operation)) if select_statement?
+
+        push.complete if under_capacity?
+        push.signal if select_statement?
+        push.close if closed?
+
+        push.wait(mutex)
+
+        fail 'cannot push to a closed channel' if closed? && !select_statement?
         self
       end
     end
@@ -72,34 +80,52 @@ module Going
     # Receives data from the channel. If the channel is already empty,
     # waits until a thread pushes to it.
     #
-    def pop
+    def shift(&on_complete)
       synchronize do
-        return if closed?
-        wait_for_push if messages.empty?
-        signal_pop
-        check_for_close
-        messages.shift
+        shift = Shift.new(select_statement: select_statement, &on_complete)
+        shifts << shift
+
+        pair_with_push shift
+
+        select_statement.when_complete(shift, shifts, &method(:remove_operation)) if select_statement?
+
+        shift.signal if select_statement?
+        shift.close if closed?
+
+        shift.wait(mutex)
+
+        throw :close if closed? && !select_statement? && shift.incomplete?
+        shift.message
       end
     end
 
     #
-    # Alias of pop
+    # Alias of shift
     #
-    alias_method :receive, :pop
-    alias_method :next, :pop
+    alias_method :receive, :shift
+    alias_method :next, :shift
 
     #
-    # Delegate size, length, and empty? to the messages queue
+    # Returns the number of messages in the channel
     #
-    def_delegators :messages, :size, :empty?
+    def size
+      [capacity, pushes.size].min
+    end
 
     #
     # Alias of size
     #
     alias_method :length, :size
 
+    #
+    # Returns whether the channel is empty.
+    #
+    def empty?
+      size == 0
+    end
+
     def inspect
-      inspection = [:capacity, :messages].map do |attr|
+      inspection = [:capacity, :size].map do |attr|
         "#{attr}: #{send(attr).inspect}"
       end
       "#<#{self.class} #{inspection.join(', ')}>"
@@ -107,35 +133,59 @@ module Going
 
     private
 
-    def_delegators :@mutex, :synchronize
+    attr_reader :mutex, :pushes, :shifts
+
+    def synchronize(&blk)
+      mutex.synchronize(&blk)
+    end
 
-    def messages
-      @messages ||= []
+    def pair_with_push(shift)
+      pushes.each_with_index.any? do |push, index|
+        if push.select_statement != select_statement && shift.complete(push)
+          complete_next_push_now_that_channel_under_capacity
+          shifts.pop
+          pushes.delete_at index
+          true
+        end
+      end
     end
 
-    def signal_pop
-      @push_semaphore.signal
+    def pair_with_shift(push)
+      shifts.each_with_index.any? do |shift, index|
+        if shift.select_statement != select_statement && shift.complete(push)
+          pushes.pop
+          shifts.delete_at index
+          true
+        end
+      end
+    end
+
+    def remove_operation(operation, queue)
+      synchronize do
+        index = queue.index(operation)
+        queue.delete_at index if index
+      end
     end
 
-    def wait_for_pop
-      @push_semaphore.wait(@mutex)
+    def complete_next_push_now_that_channel_under_capacity
+      push = pushes[capacity]
+      push.complete if push && push.incomplete?
     end
 
-    def signal_push
-      @pop_semaphore.signal
+    def pushes_over_capacity!
+      pushes.slice!(capacity, pushes.size) || []
     end
 
-    def wait_for_push
-      @pop_semaphore.wait(@mutex)
+    def under_capacity?
+      pushes.size <= capacity
     end
 
-    def broadcast_close
-      @push_semaphore.broadcast
-      @pop_semaphore.broadcast
+    def select_statement
+      SelectStatement.instance || NilSelectStatement.instance
     end
 
-    def check_for_close
-      throw :close if closed?
+    def select_statement?
+      SelectStatement.instance?
     end
   end
 end

data/lib/going/nil_select_statement.rb

@@ -0,0 +1,27 @@
+module Going
+  class NilSelectStatement
+    include Singleton
+
+    def !=(other)
+      true
+    end
+
+    def !
+      true
+    end
+
+    def nil?
+      true
+    end
+
+    def once
+      yield
+    end
+
+    def complete(*args)
+    end
+
+    def secondary_complete(*args)
+    end
+  end
+end

data/lib/going/operation/push.rb

@@ -0,0 +1,15 @@
+module Going
+  class Push < Operation
+    def complete
+      super
+      select_statement.complete(&on_complete)
+    end
+
+    def close
+      super
+      select_statement.secondary_complete do
+        fail 'cannot push to a closed channel'
+      end
+    end
+  end
+end

data/lib/going/operation/shift.rb

@@ -0,0 +1,31 @@
+module Going
+  class Shift < Operation
+    def complete(push)
+      select_statement.once do
+        push.select_statement.once do
+          self.message = push.message
+
+          super()
+          push.complete
+          notify_select_statement
+          true
+        end
+      end
+    end
+
+    def close
+      super
+      notify_select_statement
+    end
+
+    private
+
+    def notify_select_statement
+      select_statement.complete(message, ok: ok?, &on_complete)
+    end
+
+    def ok?
+      !closed?
+    end
+  end
+end

data/lib/going/operation.rb

@@ -0,0 +1,52 @@
+module Going
+  class Operation
+    extend BooleanAttrReader
+
+    attr_accessor :message
+    attr_reader :select_statement
+
+    def initialize(opts = {}, &on_complete)
+      @message = opts[:message]
+      @select_statement = opts[:select_statement]
+      @on_complete = on_complete
+
+      @completed = false
+      @closed = false
+      @signaled = false
+
+      @semaphore = ConditionVariable.new
+    end
+
+    def wait(mutex)
+      semaphore.wait(mutex) until wake?
+    end
+
+    def signal
+      @signaled = true
+      semaphore.signal
+    end
+
+    def complete
+      @completed = true
+      signal
+    end
+
+    def close
+      @closed = true
+      signal
+    end
+
+    def incomplete?
+      !completed?
+    end
+
+    private
+
+    def wake?
+      signaled? || completed? || closed?
+    end
+
+    attr_reader :semaphore, :on_complete
+    battr_reader :signaled, :completed, :closed, :select_statement
+  end
+end

data/lib/going/select_helper.rb

@@ -0,0 +1,30 @@
+module Going
+  #
+  # Helper methods to emulate Go's Select Cases.
+  #
+  class SelectHelper
+    include Singleton
+
+    #
+    # A case statement that will succeed immediately.
+    #
+    def default(&blk)
+      Channel.new(1) do |ch|
+        ch.push(nil, &blk)
+      end
+    end
+
+    #
+    # A case statement that will succeed after +seconds+ seconds.
+    #
+    def timeout(seconds, &blk)
+      Channel.new do |ch|
+        Going.go do
+          sleep seconds
+          ch.receive
+        end
+        ch.push(nil, &blk)
+      end
+    end
+  end
+end

data/lib/going/select_statement.rb

@@ -0,0 +1,121 @@
+module Going
+
+  class SelectStatement
+    extend BooleanAttrReader
+
+    class << self
+      def instance
+        Thread.current[global_key]
+      end
+
+      def instance?
+        !instance.nil?
+      end
+
+      def new_instance
+        self.instance = new
+      end
+
+      def reset
+        self.instance = nil
+      end
+
+      private
+
+      def instance=(select_statement)
+        Thread.current[global_key] = select_statement
+      end
+
+      def global_key
+        @global_key ||= "Going_#{Going::SelectStatement.object_id}"
+      end
+    end
+
+    def initialize
+      @completed = false
+      @once_mutex = Mutex.new
+      @complete_mutex = Mutex.new
+      @semaphore = ConditionVariable.new
+      @when_completes = []
+
+      @args = nil
+      @on_complete = nil
+    end
+
+    def select(&blk)
+      select_helper = SelectHelper.instance
+      if blk.arity == 1
+        yield select_helper
+      else
+        select_helper.instance_eval(&blk)
+      end
+
+      wait
+      cleanup
+      call_completion_block
+    end
+
+    def when_complete(*args, &callback)
+      when_completes << proc { callback.call(*args) }
+    end
+
+    def complete(*args, &on_complete)
+      complete_mutex.synchronize do
+        if !completed?
+          @args = args
+          @on_complete = on_complete
+          @completed = true
+          @secondary_completed = true
+          semaphore.signal
+        end
+      end
+    end
+
+    def secondary_complete(*args, &on_complete)
+      complete_mutex.synchronize do
+        if !secondary_completed?
+          @args = args
+          @on_complete = on_complete
+          @secondary_completed = true
+          semaphore.signal
+        end
+      end
+    end
+
+    def once(*args, &blk)
+      once_mutex.synchronize do
+        yield(*args) if block_given? && incomplete?
+      end
+    end
+
+    private
+
+    attr_reader :semaphore, :once_mutex, :complete_mutex, :when_completes
+    attr_reader :on_complete, :args
+    battr_reader :completed, :secondary_completed
+
+    def wait
+      complete_mutex.synchronize do
+        semaphore.wait(complete_mutex) until wake?
+      end
+    end
+
+    def incomplete?
+      complete_mutex.synchronize do
+        !completed?
+      end
+    end
+
+    def wake?
+      completed? || secondary_completed?
+    end
+
+    def cleanup
+      when_completes.each(&:call)
+    end
+
+    def call_completion_block
+      on_complete.call(*args) if on_complete
+    end
+  end
+end

data/lib/going/version.rb

@@ -1,3 +1,3 @@
 module Going
-  VERSION = '0.0.3'
+  VERSION = '1.0.0'
 end

data/lib/going.rb

@@ -1,5 +1,14 @@
 require 'thread'
+require 'singleton'
+
+require 'going/boolean_attr_reader'
 require 'going/channel'
+require 'going/select_statement'
+require 'going/nil_select_statement'
+require 'going/select_helper'
+require 'going/operation'
+require 'going/operation/shift'
+require 'going/operation/push'
 require 'going/version'
 
 module Going
@@ -9,4 +18,17 @@ module Going
   def self.go(*args, &blk)
     Thread.new(*args, &blk)
   end
+
+  #
+  # Creates a synchronous block that will select the first
+  # channel operation to complete. Only one operation inside
+  # the block will complete and any operations that are
+  # incomplete will be removed afterwards.
+  #
+  def self.select(&blk)
+    fail 'a block must be passed' unless block_given?
+    select = SelectStatement.new_instance
+    select.select(&blk)
+    SelectStatement.reset
+  end
 end

data/spec/going/channel_spec.rb

@@ -1,9 +1,22 @@
+require 'going'
+
 describe Going::Channel do
   subject(:channel) { Going::Channel.new }
+  let(:buffered_channel) { Going::Channel.new 1 }
+
   def elapsed_time(original_time)
     (Time.now - original_time)
   end
 
+  def sleeper(channel, queue, size)
+    fail "channel does not respond to #{queue}" unless channel.respond_to? queue, true
+    begin
+      Thread.pass
+      sleep 0.1
+    end until channel.send(queue).size == size
+    expect(channel.send(queue).size).to eq(size)
+  end
+
   describe '.new' do
     it 'defaults capacity to 0' do
       expect(channel.capacity).to eq(0)
@@ -48,36 +61,35 @@ describe Going::Channel do
 
     it 'will wake a blocked push' do
       Going.go do
-        sleep 0.1
+        sleeper channel, :pushes, 1
         channel.close
       end
-      expect { channel.push 1 }.to throw_symbol(:close)
+      expect { channel.push 1 }.to raise_error
     end
 
-    it 'will wake a blocked push' do
+    it 'will wake a blocked shift' do
       Going.go do
-        sleep 0.1
+        sleeper channel, :shifts, 1
         channel.close
       end
       expect { channel.receive }.to throw_symbol(:close)
     end
 
     it 'will reject all but the first #capacity pushes' do
-      channel = Going::Channel.new 2
-      Going.go do
-        sleep 0.1
-        channel.close
-      end
-      catch :close do
+      begin
+        channel = Going::Channel.new 2
+        Going.go do
+          sleeper channel, :pushes, 3
+          channel.close
+        end
         3.times { |i| channel.push i }
+      rescue
+        expect(channel.size).to eq(2)
       end
-      expect(channel.size).to eq(2)
     end
   end
 
   describe '#push' do
-    subject(:channel) { Going::Channel.new 1 }
-
     it 'is aliased as #<<' do
       expect(channel.method(:<<)).to eq(channel.method(:push))
     end
@@ -93,13 +105,13 @@ describe Going::Channel do
 
     it 'will not block if channel is under capacity' do
       now = Time.now
-      channel.push 1
+      buffered_channel.push 1
       expect(elapsed_time(now)).to be < 0.2
     end
 
     it 'will block if channel is over capacity' do
-      channel.push 1
       Going.go do
+        sleeper channel, :pushes, 1
         sleep 0.25
         channel.receive
       end
@@ -109,50 +121,73 @@ describe Going::Channel do
     end
 
     it 'will push messages in order' do
-      channel.push 1
+      buffered_channel.push 1
       Going.go do
-        channel.push 2
+        sleeper buffered_channel, :pushes, 1
+        buffered_channel.push 2
       end
       Going.go do
-        sleep 0.05
-        channel.push 3
+        sleeper buffered_channel, :pushes, 2
+        buffered_channel.push 3
       end
-      sleep 0.1
+
+      sleeper buffered_channel, :pushes, 3
       1.upto(3).each do |i|
-        expect(channel.receive).to eq(i)
+        expect(buffered_channel.receive).to eq(i)
       end
     end
 
     it 'returns the channel' do
-      expect(channel.push(1)).to be(channel)
+      expect(buffered_channel.push(1)).to be(buffered_channel)
     end
-  end
 
-  describe '#pop' do
-    subject(:channel) { Going::Channel.new 1 }
+    context 'when a shift is from a select_statement' do
+      context 'when select_statement is already completed' do
+        it 'attempts to complete with next shift' do
+          i = nil
+          Going.select do |s|
+            channel.receive
+            s.default
+            th = Going.go do
+              i = channel.receive
+            end
+            Going.go do
+              sleeper channel, :shifts, 2
+              channel.push 1
+              th.join
+            end.join
+          end
+
+          expect(i).to be(1)
+        end
+      end
+    end
+  end
 
+  describe '#shift' do
     it 'is aliased as #receive' do
-      expect(channel.method(:receive)).to eq(channel.method(:pop))
+      expect(channel.method(:receive)).to eq(channel.method(:shift))
     end
 
     it 'is aliased as #next' do
-      expect(channel.method(:next)).to eq(channel.method(:pop))
+      expect(channel.method(:next)).to eq(channel.method(:shift))
     end
 
     it 'returns the next message' do
-      channel.push 1
-      expect(channel.receive).to eq(1)
+      buffered_channel.push 1
+      expect(buffered_channel.receive).to eq(1)
     end
 
     it 'will not block if channel is not empty' do
-      channel.push 1
+      buffered_channel.push 1
       now = Time.now
-      channel.receive
+      buffered_channel.receive
       expect(elapsed_time(now)).to be < 0.2
     end
 
     it 'will block if channel is empty' do
       Going.go do
+        sleeper channel, :shifts, 1
         sleep 0.25
         channel.push 1
       end
@@ -161,16 +196,39 @@ describe Going::Channel do
       expect(elapsed_time(now)).to be > 0.2
     end
 
-    it 'returns nil if closed' do
-      channel.close
-      expect(channel.receive).to be_nil
+    context 'when closed' do
+      it 'returns next message if any' do
+        buffered_channel.push 1
+        buffered_channel.close
+        expect(buffered_channel.receive).to eq(1)
+      end
+
+      it 'throws :close if no messages' do
+        channel.close
+        expect { channel.receive }.to throw_symbol(:close)
+      end
     end
 
-    it 'does not block if closed' do
-      channel.close
-      now = Time.now
-      channel.receive
-      expect(elapsed_time(now)).to be < 0.2
+    context 'when a push is from a select_statement' do
+      context 'when select_statement is already completed' do
+        it 'attempts to complete with next push' do
+          i = nil
+
+          Going.select do |s|
+            channel.push 1
+            s.default
+            Going.go do
+              channel.push 2
+            end
+            Going.go do
+              sleeper channel, :pushes, 2
+              i = channel.receive
+            end.join
+          end
+
+          expect(i).to be(2)
+        end
+      end
     end
   end
 
@@ -191,23 +249,39 @@ describe Going::Channel do
       channel.receive
       expect(channel.size).to eq(0)
     end
+
+    it 'returns 0 for unbuffered channel' do
+      Going.go do
+        channel.push 1
+      end
+      sleeper channel, :pushes, 1
+      expect(channel.size).to eq(0)
+    end
   end
 
   describe '#empty?' do
-    it 'returns true when no messages in channel' do
-      expect(channel).to be_empty
+    context 'when capacity is 0' do
+      it 'returns true when no messages in channel' do
+        expect(channel).to be_empty
+      end
+
+      it 'returns true even if blocked pushes' do
+        Going.go do
+          channel.push 1
+        end
+        sleeper channel, :pushes, 1
+        expect(channel).to be_empty
+      end
     end
 
     context 'when capacity is greater than 0' do
-      subject(:channel) { Going::Channel.new 1 }
-
-      it 'returns true when messages in channel' do
-        expect(channel).to be_empty
+      it 'returns true when no messages in channel' do
+        expect(buffered_channel).to be_empty
       end
 
       it 'returns false when messages in channel' do
-        channel.push 1
-        expect(channel).not_to be_empty
+        buffered_channel.push 1
+        expect(buffered_channel).not_to be_empty
       end
     end
   end

data/spec/going/select_statement_spec.rb

@@ -0,0 +1,364 @@
+require 'going'
+
+describe Going::SelectStatement do
+  let(:channel) { Going::Channel.new }
+  let(:buffered_channel) { Going::Channel.new 1 }
+  let(:spy) { Spy.new }
+  let(:dont_call) { Spy.new }
+
+  def elapsed_time(original_time)
+    (Time.now - original_time)
+  end
+
+  def sleeper(channel, queue, size)
+    fail "channel does not respond to #{queue}" unless channel.respond_to? queue, true
+    begin
+      Thread.pass
+      sleep 0.1
+    end until channel.send(queue).size == size
+    expect(channel.send(queue).size).to eq(size)
+  end
+
+  describe 'Going.select' do
+    it 'blocks until a channel operation succeeds' do
+      now = Time.now
+      Going.select do |s|
+        channel.receive
+
+        Going.go do
+          sleep 0.25
+          channel.push 1
+        end
+      end
+      expect(elapsed_time(now)).to be > 0.2
+    end
+
+    it 'does not block if a channel operation immediately succeeds' do
+      now = Time.now
+      Going.select do |s|
+        buffered_channel.push 1
+      end
+      expect(elapsed_time(now)).to be < 0.2
+    end
+
+    it 'calls block on operation that succeeds' do
+      third_channel = Going::Channel.new 1
+      Going.select do |s|
+        channel.receive(&dont_call)
+        buffered_channel.push(1, &spy)
+        third_channel.push(2, &dont_call)
+      end
+      expect(spy).to be_called
+      expect(dont_call).not_to be_called
+    end
+
+    it 'does not call other blocks' do
+      Going.select do |s|
+        channel.push(1, &dont_call)
+        buffered_channel.push 2
+        Going.go do
+          channel.receive
+        end
+      end
+      sleeper channel, :shifts, 1
+      expect(dont_call).not_to be_called
+    end
+
+    it 'can not succeed from own operations' do
+      now = Time.now
+      Going.select do |s|
+        channel.push(1, &dont_call)
+        channel.receive(&spy)
+        channel.push(2, &dont_call)
+        Going.go do
+          sleep 0.25
+          channel.push(3)
+        end
+      end
+      expect(elapsed_time(now)).to be > 0.2
+      expect(spy.args.first).to eq(3)
+      expect(dont_call).not_to be_called
+    end
+
+    it 'does not complete other operations if already succeeded' do
+      Going.select do |s|
+        buffered_channel.receive(&dont_call)
+        s.default
+        Going.go do
+          buffered_channel.push 1
+        end.join
+      end
+      expect(dont_call).not_to be_called
+    end
+
+    it 'does not preserve channel operations that are not selected' do
+      Going.select do |s|
+        buffered_channel.push 1
+        buffered_channel.push 2
+        Going.go do
+          buffered_channel.receive
+        end
+      end
+      expect(buffered_channel.size).to eq(0)
+    end
+
+    context 'buffered channels' do
+      it 'succeeds when blocked push is now under capacity' do
+        buffered_channel.push 1
+        Going.select do |s|
+          buffered_channel.push(2, &spy)
+          Going.go do
+            buffered_channel.receive
+          end
+        end
+        expect(spy).to be_called
+      end
+    end
+  end
+
+  describe 'succeeding push' do
+    it 'passes nothing to the block' do
+      Going.select do |s|
+        buffered_channel.push(1, &spy)
+      end
+
+      expect(spy.args).to eq([])
+    end
+  end
+
+  describe 'succeeding receive' do
+    it 'passes message as arg to the block' do
+      buffered_channel.push 1
+      Going.select do |s|
+        buffered_channel.receive(&spy)
+      end
+
+      expect(spy.args.first).to eq(1)
+    end
+
+    it "passes true as `ok` param to the block" do
+      buffered_channel.push 1
+      Going.select do |s|
+        buffered_channel.receive(&spy)
+      end
+
+      expect(spy.args.last).to eq({ ok: true })
+    end
+  end
+
+  describe 'closed channel' do
+    before(:each) { channel.close }
+
+    describe 'push' do
+      context 'when select fails' do
+        it 'raises error' do
+          expect do
+            Going.select do |s|
+              channel.push 1
+            end
+          end.to raise_error
+        end
+
+        it 'does not call block' do
+          begin
+            Going.select do |s|
+              channel.push(1, &dont_call)
+            end
+          rescue
+            expect(dont_call).not_to be_called
+          end
+        end
+      end
+
+      context 'when select succeeds' do
+        it 'does not raise error' do
+          expect do
+            Going.select do |s|
+              channel.push 1
+              s.default
+            end
+          end.not_to raise_error
+        end
+
+        it 'does not call block' do
+          Going.select do |s|
+            channel.push(1, &dont_call)
+            s.default
+          end
+          expect(dont_call).not_to be_called
+        end
+      end
+    end
+
+    describe 'receive' do
+      it 'can receive buffered messages' do
+        buffered_channel.push 1
+        buffered_channel.close
+
+        Going.select do |s|
+          buffered_channel.receive(&spy)
+        end
+        expect(spy.args.first).to eq(1)
+      end
+
+      it 'is considered a success' do
+        Going.select do |s|
+          channel.receive(&spy)
+        end
+        expect(spy).to be_called
+      end
+
+      it 'passes nil as arg to the block' do
+        Going.select do |s|
+          channel.receive(&spy)
+        end
+        expect(spy.args.first).to be_nil
+      end
+
+      it "passes false as `ok` param to the block" do
+        Going.select do |s|
+          channel.receive(&spy)
+        end
+        expect(spy.args.last).to eq({ ok: false })
+      end
+    end
+  end
+
+  describe 'closing channel' do
+    describe 'push' do
+      context 'when select fails' do
+        it 'blocked push raises error' do
+          expect do
+            Going.select do |s|
+              channel.push 1
+              channel.close
+            end
+          end.to raise_error
+        end
+
+        it 'does not call block' do
+          begin
+            Going.select do |s|
+              channel.push(1, &dont_call)
+              channel.close
+            end
+          rescue
+            expect(dont_call).not_to be_called
+          end
+        end
+      end
+
+      context 'when select succeeds' do
+        it 'does not raise error if select succeeds' do
+          Going.select do |s|
+            channel.push 1
+            channel.receive
+            channel.close
+          end
+        end
+
+        it 'does not call block' do
+          Going.select do |s|
+            channel.push(1, &dont_call)
+            channel.receive
+            channel.close
+          end
+          expect(dont_call).not_to be_called
+        end
+      end
+    end
+
+    describe 'receive' do
+      it 'is considered a success' do
+        Going.select do |s|
+          channel.receive(&spy)
+          channel.close
+        end
+        expect(spy).to be_called
+      end
+
+      it 'passes nil as arg to the block' do
+        Going.select do |s|
+          channel.receive(&spy)
+          channel.close
+        end
+        expect(spy.args.first).to be_nil
+      end
+
+      it "passes false as `ok` param to the block" do
+        Going.select do |s|
+          channel.receive(&spy)
+          channel.close
+        end
+        expect(spy.args.last).to eq({ ok: false })
+      end
+    end
+  end
+
+
+  describe '#default' do
+    it 'never blocks' do
+      now = Time.now
+      Going.select do |s|
+        s.default
+      end
+      expect(elapsed_time(now)).to be < 0.2
+    end
+
+    it 'is not called if select statement is already succeeded' do
+      Going.select do |s|
+        buffered_channel.push 1
+        s.default(&dont_call)
+      end
+      expect(dont_call).not_to be_called
+    end
+
+    it 'calls its block on success' do
+      Going.select do |s|
+        s.default(&spy)
+      end
+      expect(spy).to be_called
+    end
+
+    it 'passes nothing to the block' do
+      Going.select do |s|
+        s.default(&spy)
+      end
+      expect(spy.args).to eq([])
+    end
+  end
+
+  describe '#timeout' do
+    it 'completes the select statement after given time' do
+      now = Time.now
+      Going.select do |s|
+        s.timeout(0.25)
+      end
+      expect(elapsed_time(now)).to be > 0.2
+    end
+
+    it 'is not called if select statement is already completed' do
+      ch = nil
+      Going.select do |s|
+        ch = s.timeout(0.1, &dont_call)
+        s.default
+      end
+      sleeper ch, :pushes, 0
+      expect(dont_call).not_to be_called
+    end
+
+    it 'calls its block on success' do
+      Going.select do |s|
+        s.timeout(0, &spy)
+      end
+      expect(spy).to be_called
+    end
+
+    it 'passes nothing to the block' do
+      Going.select do |s|
+        s.timeout(0, &spy)
+      end
+      expect(spy.args).to eq([])
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -16,6 +16,11 @@
 # See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
 
 require 'going'
+require 'timeout'
+
+Thread.abort_on_exception = true
+
+Dir.glob(File.join(File.dirname(File.absolute_path(__FILE__)), 'support', '*.rb')) { |file| require file}
 
 RSpec.configure do |config|
   config.filter_run :focus
@@ -37,4 +42,10 @@ RSpec.configure do |config|
     mocks.syntax = :expect
     mocks.verify_partial_doubles = true
   end
+
+  config.around(:each) do |example|
+    Timeout::timeout(5) do
+      example.run
+    end
+  end
 end

data/spec/support/spy.rb

@@ -0,0 +1,22 @@
+class Spy
+  attr_reader :args
+
+  def initialize
+    @called = false
+    @args = nil
+  end
+
+  def call(*args)
+    @called = true
+    @args = args
+  end
+
+  def called?
+    !!@called
+  end
+
+  def to_proc
+    method(:call).to_proc
+  end
+end
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: going
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 1.0.0
 platform: ruby
 authors:
 - Justin Ridgewell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-07-22 00:00:00.000000000 Z
+date: 2014-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -68,13 +68,22 @@ files:
 - Rakefile
 - going.gemspec
 - lib/going.rb
+- lib/going/boolean_attr_reader.rb
 - lib/going/channel.rb
 - lib/going/kernel.rb
+- lib/going/nil_select_statement.rb
+- lib/going/operation.rb
+- lib/going/operation/push.rb
+- lib/going/operation/shift.rb
+- lib/going/select_helper.rb
+- lib/going/select_statement.rb
 - lib/going/version.rb
 - spec/going/channel_spec.rb
 - spec/going/kernel_spec.rb
+- spec/going/select_statement_spec.rb
 - spec/going_spec.rb
 - spec/spec_helper.rb
+- spec/support/spy.rb
 homepage: https://github.com/jridgewell/going
 licenses:
 - MIT
@@ -102,5 +111,7 @@ summary: Go for Ruby
 test_files:
 - spec/going/channel_spec.rb
 - spec/going/kernel_spec.rb
+- spec/going/select_statement_spec.rb
 - spec/going_spec.rb
 - spec/spec_helper.rb
+- spec/support/spy.rb