concurrent-ruby-edge 0.2.0.pre4 → 0.2.0.pre5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8589b43e4b23f4d4bb73cddf2123b436e0ea90ba
-  data.tar.gz: baa80cc8ded0dc8a050ce3a64a933183575584a4
+  metadata.gz: 49c297b646de061530808c991d1e19221dc1b6a7
+  data.tar.gz: 1301f31a7ff10f078525eb5e3158428b012d1517
 SHA512:
-  metadata.gz: 2c3fbd2d6e8718e62457e39c61bfe95a0da959072af5e05d2162fd12d8aa1aa15137428916766bde9b32f7359f9cab8b21b5883851d5bf432541e1dd531ca719
-  data.tar.gz: a538eca680505fb8b3192fb6a1b5dbcdcc63ac757d56b00bca5745256bd01d007f40d50aad0c4db2df6a33f13e42efe7af384595b3998e9e4c0166094fa5635a
+  metadata.gz: 9b4850c4f01294b27c7bfeae6a0ad37ee22a255be4097e318fcfeca022de20f5436a756ea7ff7754f39148483c728a6867267b585240719d2d9981fc317c1944
+  data.tar.gz: 46e2136e70cc3b20d1fd3f4a118010b4c26190bd218811fea3a3e53cb03668a89a5744f7f59e71aefa498ed6936f61deab8d4fe525c0a466ff9f95e620e2ed3a

data/lib/concurrent/actor/behaviour/abstract.rb

@@ -6,7 +6,6 @@ module Concurrent
       class Abstract
         include TypeCheck
         include InternalDelegations
-        include Concern::Logging
 
         attr_reader :core, :subsequent
 
@@ -42,7 +41,7 @@ module Concurrent
         def reject_envelope(envelope)
           envelope.reject! ActorTerminated.new(reference)
           dead_letter_routing << envelope unless envelope.future
-          log DEBUG, "rejected #{envelope.message} from #{envelope.sender_path}"
+          log(DEBUG) { "rejected #{envelope.message} from #{envelope.sender_path}"}
         end
       end
     end

data/lib/concurrent/actor/behaviour/sets_results.rb

@@ -14,7 +14,7 @@ module Concurrent
           result = pass envelope
           if result != MESSAGE_PROCESSED && !envelope.future.nil?
             envelope.future.success result
-            log DEBUG, "finished processing of #{envelope.message.inspect}"
+            log(DEBUG) { "finished processing of #{envelope.message.inspect}"}
           end
           nil
         rescue => error

data/lib/concurrent/actor/context.rb

@@ -24,7 +24,6 @@ module Concurrent
     class AbstractContext
       include TypeCheck
       include InternalDelegations
-      include Concern::Logging
 
       attr_reader :core
 

data/lib/concurrent/actor/core.rb

@@ -91,7 +91,7 @@ module Concurrent
       # @param [Envelope] envelope
       def on_envelope(envelope)
         schedule_execution do
-          log DEBUG, "was #{envelope.future ? 'asked' : 'told'} #{envelope.message.inspect} by #{envelope.sender}"
+          log(DEBUG) { "was #{envelope.future ? 'asked' : 'told'} #{envelope.message.inspect} by #{envelope.sender}" }
           process_envelope envelope
         end
         nil
@@ -128,7 +128,7 @@ module Concurrent
       end
 
       def broadcast(public, event)
-        log DEBUG, "event: #{event.inspect} (#{public ? 'public' : 'private'})"
+        log(DEBUG) { "event: #{event.inspect} (#{public ? 'public' : 'private'})" }
         @first_behaviour.on_event(public, event)
       end
 

data/lib/concurrent/actor/default_dead_letter_handler.rb

@@ -2,7 +2,7 @@ module Concurrent
   module Actor
     class DefaultDeadLetterHandler < RestartingContext
       def on_message(dead_letter)
-        log INFO, "got dead letter #{dead_letter.inspect}"
+        log(INFO) { "got dead letter #{dead_letter.inspect}"}
       end
     end
   end

data/lib/concurrent/actor/internal_delegations.rb

@@ -2,6 +2,7 @@ module Concurrent
   module Actor
     module InternalDelegations
       include PublicDelegations
+      include Logger::Severity
 
       # @see Core#children
       def children

data/lib/concurrent/channel.rb

@@ -12,7 +12,7 @@ module Concurrent
     include Enumerable
 
     # NOTE: Move to global IO pool once stable
-    GOROUTINES = Concurrent::CachedThreadPool.new
+    GOROUTINES = Concurrent::CachedThreadPool.new(auto_terminate: true)
     private_constant :GOROUTINES
 
     BUFFER_TYPES = {
@@ -48,22 +48,22 @@ module Concurrent
         return
       end
 
-      size = opts[:size]
+      capacity = opts[:capacity] || opts[:size]
       buffer = opts[:buffer]
 
-      if size && buffer == :unbuffered
-        raise ArgumentError.new('unbuffered channels cannot have a size')
-      elsif size.nil? && buffer.nil?
+      if capacity && buffer == :unbuffered
+        raise ArgumentError.new('unbuffered channels cannot have a capacity')
+      elsif capacity.nil? && buffer.nil?
         self.buffer = BUFFER_TYPES[:unbuffered].new
-      elsif size == 0 && buffer == :buffered
+      elsif capacity == 0 && buffer == :buffered
         self.buffer = BUFFER_TYPES[:unbuffered].new
       elsif buffer == :unbuffered
         self.buffer = BUFFER_TYPES[:unbuffered].new
-      elsif size.nil? || size < 1
-        raise ArgumentError.new('size must be at least 1 for this buffer type')
+      elsif capacity.nil? || capacity < 1
+        raise ArgumentError.new('capacity must be at least 1 for this buffer type')
       else
         buffer ||= :buffered
-        self.buffer = BUFFER_TYPES[buffer].new(size)
+        self.buffer = BUFFER_TYPES[buffer].new(capacity)
       end
 
       self.validator = opts.fetch(:validator, DEFAULT_VALIDATOR)
@@ -116,20 +116,25 @@ module Concurrent
     end
 
     def take
-      item, _ = self.next
-      item
+      item = do_take
+      item == Concurrent::NULL ? nil : item
     end
     alias_method :receive, :take
     alias_method :~, :take
 
     def take!
-      item, _ = do_next
-      raise Error if item == Buffer::NO_VALUE
+      item = do_take
+      raise Error if item == Concurrent::NULL
       item
     end
 
     def take?
-      item, _ = self.next?
+      item = do_take
+      item = if item == Concurrent::NULL
+               Concurrent::Maybe.nothing
+             else
+               Concurrent::Maybe.just(item)
+             end
       item
     end
 
@@ -150,13 +155,13 @@ module Concurrent
     #   end
     def next
       item, more = do_next
-      item = nil if item == Buffer::NO_VALUE
+      item = nil if item == Concurrent::NULL
       return item, more
     end
 
     def next?
       item, more = do_next
-      item = if item == Buffer::NO_VALUE
+      item = if item == Concurrent::NULL
                Concurrent::Maybe.nothing
              else
                Concurrent::Maybe.just(item)
@@ -165,17 +170,17 @@ module Concurrent
     end
 
     def poll
-      (item = do_poll) == Buffer::NO_VALUE ? nil : item
+      (item = do_poll) == Concurrent::NULL ? nil : item
     end
 
     def poll!
       item = do_poll
-      raise Error if item == Buffer::NO_VALUE
+      raise Error if item == Concurrent::NULL
       item
     end
 
     def poll?
-      if (item = do_poll) == Buffer::NO_VALUE
+      if (item = do_poll) == Concurrent::NULL
         Concurrent::Maybe.nothing
       else
         Concurrent::Maybe.just(item)
@@ -186,7 +191,7 @@ module Concurrent
       raise ArgumentError.new('no block given') unless block_given?
       loop do
         item, more = do_next
-        if item != Buffer::NO_VALUE
+        if item != Concurrent::NULL
           yield(item)
         elsif !more
           break
@@ -238,7 +243,21 @@ module Concurrent
 
     private
 
-    attr_accessor :buffer, :validator
+    def validator
+      @validator
+    end
+
+    def validator=(value)
+      @validator = value
+    end
+
+    def buffer
+      @buffer
+    end
+
+    def buffer=(value)
+      @buffer = value
+    end
 
     def validate(value, allow_nil, raise_error)
       if !allow_nil && value.nil?
@@ -261,6 +280,10 @@ module Concurrent
       buffer.offer(item)
     end
 
+    def do_take
+      buffer.take
+    end
+
     def do_next
       buffer.next
     end

data/lib/concurrent/channel/buffer/base.rb

@@ -4,9 +4,6 @@ module Concurrent
   class Channel
     module Buffer
 
-      # Placeholder for when a buffer slot contains no value.
-      NO_VALUE = Object.new
-
       # Abstract base class for all Channel buffers.
       #
       # {Concurrent::Channel} objects maintain an internal, queue-like
@@ -18,11 +15,6 @@ module Concurrent
       # used as a channel buffer should extend this class.
       class Base < Synchronization::LockableObject
 
-        # @!macro [attach] channel_buffer_size_reader
-        #
-        #   The number of items currently in the buffer.
-        attr_reader :size
-
         # @!macro [attach] channel_buffer_capacity_reader
         #
         #   The maximum number of values which can be {#put} onto the buffer
@@ -53,6 +45,13 @@ module Concurrent
           true
         end
 
+        # @!macro [attach] channel_buffer_size_reader
+        #
+        #   The number of items currently in the buffer.
+        def size
+          synchronize { ns_size }
+        end
+
         # @!macro [attach] channel_buffer_empty_question
         #
         #   Predicate indicating if the buffer is empty.
@@ -61,7 +60,7 @@ module Concurrent
         #
         # @raise [NotImplementedError] until overridden in a subclass.
         def empty?
-          raise NotImplementedError
+          synchronize { ns_empty? }
         end
 
         # @!macro [attach] channel_buffer_full_question
@@ -72,7 +71,7 @@ module Concurrent
         #
         # @raise [NotImplementedError] until overridden in a subclass.
         def full?
-          raise NotImplementedError
+          synchronize { ns_full? }
         end
 
         # @!macro [attach] channel_buffer_put
@@ -116,7 +115,7 @@ module Concurrent
         #   are available the remaining items can still be taken. Once the
         #   buffer closes, no remaining items can be taken.
         #
-        #   @return [Object] the item removed from the buffer; `NO_VALUE` once
+        #   @return [Object] the item removed from the buffer; `Concurrent::NULL` once
         #     the buffer has closed.
         #
         # @raise [NotImplementedError] until overridden in a subclass.
@@ -126,19 +125,16 @@ module Concurrent
 
         # @!macro [attach] channel_buffer_next
         #
-        #   Take the next item from the buffer and also return a boolean
-        #   indicating if subsequent items can be taken. Used for iterating
+        #   Take the next "item" from the buffer and also return a boolean
+        #   indicating if "more" items can be taken. Used for iterating
         #   over a buffer until it is closed and empty.
         #
         #   If the buffer is open but no items remain the calling thread will
         #   block until an item is available. The second of the two return
-        #   values, a boolean, will always be `true` when the buffer is open.
-        #   When the buffer is closed but more items remain the second return
-        #   value will also be `true`. When the buffer is closed and the last
-        #   item is taken the second return value will be `false`. When the
-        #   buffer is both closed and empty the first return value will be
-        #   `NO_VALUE` and the second return value will be `false`.
-        #   be `false` when the buffer is both closed and empty.
+        #   values, "more" (a boolean), will always be `true` when the buffer is
+        #   open. The "more" value will be `false` when the channel has been
+        #   closed and all values have already been received. When "more" is
+        #   false the returned item will be `Concurrent::NULL`.
         #
         #   Note that when multiple threads access the same channel a race
         #   condition can occur when using this method. A call to `next` from
@@ -162,7 +158,7 @@ module Concurrent
         #   immediately. Failing to return a value does not necessarily
         #   indicate that the buffer is closed, just that it is empty.
         #
-        #   @return [Object] the next item from the buffer or `NO_VALUE` if
+        #   @return [Object] the next item from the buffer or `Concurrent::NULL` if
         #     the buffer is empty.
         #
         # @raise [NotImplementedError] until overridden in a subclass.
@@ -194,12 +190,44 @@ module Concurrent
 
         private
 
-        attr_accessor :buffer
-        attr_writer :closed, :capacity, :size
+        def buffer
+          @buffer
+        end
+
+        def buffer=(value)
+          @buffer = value
+        end
+
+        def closed=(value)
+          @closed = value
+        end
+
+        def capacity=(value)
+          @capacity = value
+        end
+
+        def size=(value)
+          @size = value
+        end
 
         def ns_initialize(*args)
         end
 
+        # @!macro channel_buffer_size_reader
+        def ns_size
+          raise NotImplementedError
+        end
+
+        # @!macro channel_buffer_empty_question
+        def ns_empty?
+          raise NotImplementedError
+        end
+
+        # @!macro channel_buffer_full_question
+        def ns_full?
+          raise NotImplementedError
+        end
+
         # @!macro channel_buffer_closed_question
         def ns_closed?
           @closed

data/lib/concurrent/channel/buffer/buffered.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/channel/buffer/base'
 
 module Concurrent
@@ -10,19 +11,6 @@ module Concurrent
       # an item is removed from the buffer, creating spare capacity.
       class Buffered < Base
 
-        # @!macro channel_buffer_empty_question
-        def empty?
-          synchronize { ns_empty? }
-        end
-
-        # @!macro channel_buffer_full_question
-        #
-        # Will return `true` once the number of items in the buffer reaches
-        # the {#size} value specified during initialization.
-        def full?
-          synchronize { ns_full? }
-        end
-
         # @!macro channel_buffer_put
         #
         # New items can be put onto the buffer until the number of items in
@@ -69,11 +57,10 @@ module Concurrent
           loop do
             synchronize do
               if ns_closed? && ns_empty?
-                return NO_VALUE, false
+                return Concurrent::NULL, false
               elsif !ns_empty?
                 item = buffer.shift
-                more = !ns_empty? || !ns_closed?
-                return item, more
+                return item, true
               end
             end
             Thread.pass
@@ -84,7 +71,7 @@ module Concurrent
         def poll
           synchronize do
             if ns_empty?
-              NO_VALUE
+              Concurrent::NULL
             else
               buffer.shift
             end
@@ -104,14 +91,19 @@ module Concurrent
           self.buffer = []
         end
 
+        # @!macro channel_buffer_size_reader
+        def ns_size
+          buffer.size
+        end
+
         # @!macro channel_buffer_empty_question
         def ns_empty?
-          buffer.length == 0
+          ns_size == 0
         end
 
         # @!macro channel_buffer_full_question
         def ns_full?
-          buffer.length == capacity
+          ns_size == capacity
         end
 
         # @!macro channel_buffer_put

data/lib/concurrent/channel/buffer/ticker.rb

@@ -1,74 +1,33 @@
+require 'concurrent/constants'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/channel/tick'
-require 'concurrent/channel/buffer/base'
+require 'concurrent/channel/buffer/timer'
 
 module Concurrent
   class Channel
     module Buffer
 
-      class Ticker < Base
-
-        def size() 1; end
-
-        def empty?() false; end
-
-        def full?() true; end
-
-        def put(item)
-          false
-        end
-
-        def offer(item)
-          false
-        end
-
-        def take
-          loop do
-            result, _ = do_poll
-            if result.nil?
-              return NO_VALUE
-            elsif result != NO_VALUE
-              return result
-            end
-          end
-        end
-
-        def next
-          loop do
-            result, _ = do_poll
-            if result.nil?
-              return NO_VALUE, false
-            elsif result != NO_VALUE
-              return result, true
-            end
-          end
-        end
-
-        def poll
-          result, _ = do_poll
-          if result.nil? || result == NO_VALUE
-            NO_VALUE
-          else
-            result
-          end
-        end
+      class Ticker < Timer
 
         private
 
         def ns_initialize(interval)
           @interval = interval.to_f
           @next_tick = Concurrent.monotonic_time + interval
+          self.capacity = 1
         end
 
         def do_poll
-          if ns_closed?
-            return nil, false
-          elsif (now = Concurrent.monotonic_time) > @next_tick
-            tick = Concurrent::Channel::Tick.new(@next_tick)
-            @next_tick = now + @interval
-            return tick, true
-          else
-            return NO_VALUE, true
+          synchronize do
+            if ns_closed?
+              return Concurrent::NULL, false
+            elsif (now = Concurrent.monotonic_time) >= @next_tick
+              tick = Concurrent::Channel::Tick.new(@next_tick)
+              @next_tick = now + @interval
+              return tick, true
+            else
+              return nil, true
+            end
           end
         end
       end

data/lib/concurrent/channel/buffer/timer.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/utility/monotonic_time'
 require 'concurrent/channel/tick'
 require 'concurrent/channel/buffer/base'
@@ -8,16 +9,6 @@ module Concurrent
 
       class Timer < Base
 
-        def size() 1; end
-
-        def empty?
-          synchronized { @empty }
-        end
-
-        def full?
-          !empty?
-        end
-
         def put(item)
           false
         end
@@ -27,44 +18,59 @@ module Concurrent
         end
 
         def take
-          self.next.first
+          loop do
+            tick, _ = do_poll
+            if tick
+              return tick
+            else
+              Thread.pass
+            end
+          end
         end
 
         def next
           loop do
-            status, tick = do_poll
-            if status == :tick
-              return tick, false
-              # AFAIK a Go timer will block forever if stopped
-              #elsif status == :closed
-              #return false, false
-            end
+            tick, more = do_poll
+            return tick, more if tick
             Thread.pass
           end
         end
 
         def poll
-          status, tick = do_poll
-          status == :tick ? tick : NO_VALUE
+          tick, _ = do_poll
+          tick = Concurrent::NULL unless tick
+          tick
         end
 
         private
 
         def ns_initialize(delay)
           @tick = Concurrent.monotonic_time + delay.to_f
-          @closed = false
-          @empty = false
+          self.capacity = 1
+        end
+
+        def ns_size
+          0
+        end
+
+        def ns_empty?
+          false
+        end
+
+        def ns_full?
+          true
         end
 
         def do_poll
           synchronize do
-            return :closed, false if ns_closed?
-
-            if Concurrent.monotonic_time > @tick
+            if ns_closed?
+              return Concurrent::NULL, false
+            elsif Concurrent.monotonic_time >= @tick
               # only one listener gets notified
-              return :tick, Concurrent::Channel::Tick.new(@tick)
+              self.closed = true
+              return Concurrent::Channel::Tick.new(@tick), false
             else
-              return :wait, true
+              return nil, true
             end
           end
         end

data/lib/concurrent/channel/buffer/unbuffered.rb

@@ -1,3 +1,4 @@
+require 'concurrent/constants'
 require 'concurrent/channel/buffer/base'
 require 'concurrent/atomic/atomic_reference'
 
@@ -16,19 +17,21 @@ module Concurrent
       class Unbuffered < Base
 
         # @!macro channel_buffer_size_reader
-        #
-        # Always returns zero (0).
-        def size() 0; end
+        def size
+          synchronize do
+            putting.empty? ? 0 : 1
+          end
+        end
 
         # @!macro channel_buffer_empty_question
-        #
-        # Always returns `true`.
-        def empty?() true; end
+        def empty?
+          size == 0
+        end
 
         # @!macro channel_buffer_full_question
-        #
-        # Always returns `false`.
-        def full?() false; end
+        def full?
+          !empty?
+        end
 
         # @!macro channel_buffer_put
         #
@@ -85,7 +88,7 @@ module Concurrent
         # and this method will return.
         def take
           mine = synchronize do
-            return NO_VALUE if ns_closed? && putting.empty?
+            return Concurrent::NULL if ns_closed? && putting.empty?
 
             ref = Concurrent::AtomicReference.new(nil)
             if putting.empty?
@@ -110,10 +113,10 @@ module Concurrent
         # waiting to {#put} items onto the buffer. When there is a thread
         # waiting to put an item this method will take the item and return
         # it immediately. When there are no threads waiting to put or the
-        # buffer is closed, this method will return `NO_VALUE` immediately.
+        # buffer is closed, this method will return `Concurrent::NULL` immediately.
         def poll
           synchronize do
-            return NO_VALUE if putting.empty?
+            return Concurrent::NULL if putting.empty?
 
             put = putting.shift
             value = put.value
@@ -131,19 +134,21 @@ module Concurrent
         # @see {#take}
         def next
           item = take
-          more = synchronize { !putting.empty? }
+          more = (item != Concurrent::NULL)
           return item, more
         end
 
         private
 
-        attr_accessor :putting, :taking
+        def putting() @putting; end
+
+        def taking() @taking; end
 
         # @!macro channel_buffer_initialize
         def ns_initialize
           # one will always be empty
-          self.putting = []
-          self.taking = []
+          @putting = []
+          @taking = []
           self.closed = false
           self.capacity = 1
         end

data/lib/concurrent/channel/selector.rb

@@ -54,6 +54,7 @@ module Concurrent
       end
 
       def execute
+        raise Channel::Error.new('no clauses given') if @clauses.empty?
         loop do
           done = @clauses.each do |clause|
             result = clause.execute
@@ -63,7 +64,11 @@ module Concurrent
           Thread.pass
         end
       rescue => ex
-        @error_handler.call(ex) if @error_handler
+        if @error_handler
+          @error_handler.call(ex)
+        else
+          raise ex
+        end
       end
     end
   end

data/lib/concurrent/channel/tick.rb

@@ -1,3 +1,4 @@
+require 'concurrent/synchronization'
 require 'concurrent/utility/monotonic_time'
 
 module Concurrent
@@ -13,8 +14,9 @@ module Concurrent
     # @see Concurrent.monotonic_time
     # @see Concurrent::Channel.ticker
     # @see Concurrent::Channel.timer
-    class Tick
+    class Tick < Synchronization::Object
       include Comparable
+      safe_initialization!
 
       STRING_FORMAT = '%F %T.%6N %z %Z'.freeze
 

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -15,7 +15,8 @@ module Concurrent
 
       # @!macro [attach] atomic_markable_reference_method_initialize
       def initialize(value = nil, mark = false)
-        super(ImmutableArray[value, mark]) # ensures visibility
+        super()
+        self.reference = ImmutableArray[value, mark]
       end
 
       # @!macro [attach] atomic_markable_reference_method_compare_and_set

data/lib/concurrent/edge/future.rb

@@ -131,6 +131,8 @@ module Concurrent
     # Represents an event which will happen in future (will be completed). It has to always happen.
     class Event < Synchronization::LockableObject
       safe_initialization!
+      private(*attr_volatile_with_cas(:internal_state))
+      public :internal_state
       include Concern::Deprecation
       include Concern::Logging
 
@@ -181,17 +183,17 @@ module Concurrent
         # TODO (pitr 12-Sep-2015): replace with AtomicFixnum, avoid aba problem
         # TODO (pitr 12-Sep-2015): look at java.util.concurrent solution
         @Waiters         = LockFreeStack.new
-        @State           = AtomicReference.new PENDING
+        self.internal_state = PENDING
       end
 
       # @return [:pending, :completed]
       def state
-        @State.get.to_sym
+        internal_state.to_sym
       end
 
       # Is Event/Future pending?
       # @return [Boolean]
-      def pending?(state = @State.get)
+      def pending?(state = internal_state)
         !state.completed?
       end
 
@@ -203,7 +205,7 @@ module Concurrent
 
       # Has the Event been completed?
       # @return [Boolean]
-      def completed?(state = @State.get)
+      def completed?(state = internal_state)
         state.completed?
       end
 
@@ -314,7 +316,7 @@ module Concurrent
 
       # @!visibility private
       def complete_with(state, raise_on_reassign = true)
-        if @State.compare_and_set(PENDING, state)
+        if compare_and_set_internal_state(PENDING, state)
           #(state)
           # go to synchronized block only if there were waiting threads
           synchronize { ns_broadcast } if @Waiters.clear
@@ -370,11 +372,6 @@ module Concurrent
         @Waiters.each.to_a
       end
 
-      # @!visibility private
-      def internal_state
-        @State.get
-      end
-
       private
 
       # @return [true, false]
@@ -537,7 +534,7 @@ module Concurrent
 
       # Has Future been success?
       # @return [Boolean]
-      def success?(state = @State.get)
+      def success?(state = internal_state)
         state.completed? && state.success?
       end
 
@@ -548,7 +545,7 @@ module Concurrent
 
       # Has Future been failed?
       # @return [Boolean]
-      def failed?(state = @State.get)
+      def failed?(state = internal_state)
         state.completed? && !state.success?
       end
 
@@ -564,7 +561,7 @@ module Concurrent
       # @!macro edge.periodical_wait
       def value(timeout = nil)
         touch
-        @State.get.value if wait_until_complete timeout
+        internal_state.value if wait_until_complete timeout
       end
 
       # @return [Exception, nil] the reason of the Future's failure
@@ -572,7 +569,7 @@ module Concurrent
       # @!macro edge.periodical_wait
       def reason(timeout = nil)
         touch
-        @State.get.reason if wait_until_complete timeout
+        internal_state.reason if wait_until_complete timeout
       end
 
       # @return [Array(Boolean, Object, Exception), nil] triplet of success, value, reason
@@ -580,7 +577,7 @@ module Concurrent
       # @!macro edge.periodical_wait
       def result(timeout = nil)
         touch
-        @State.get.result if wait_until_complete timeout
+        internal_state.result if wait_until_complete timeout
       end
 
       # Wait until Future is #complete?
@@ -602,14 +599,14 @@ module Concurrent
       # @!macro edge.periodical_wait
       def value!(timeout = nil)
         touch
-        @State.get.value if wait_until_complete! timeout
+        internal_state.value if wait_until_complete! timeout
       end
 
       # @example allows failed Future to be risen
       #   raise Concurrent.future.fail
       def exception(*args)
         raise 'obligation is not failed' unless failed?
-        reason = @State.get.reason
+        reason = internal_state.reason
         if reason.is_a?(::Array)
           reason.each { |e| log ERROR, 'Edge::Future', e }
           Concurrent::Error.new 'multiple exceptions, inspect log'
@@ -728,7 +725,7 @@ module Concurrent
 
       # @!visibility private
       def complete_with(state, raise_on_reassign = true)
-        if @State.compare_and_set(PENDING, state)
+        if compare_and_set_internal_state(PENDING, state)
           @Waiters.clear
           synchronize { ns_broadcast }
           call_callbacks state
@@ -746,12 +743,12 @@ module Concurrent
 
       # @!visibility private
       def add_callback(method, *args)
-        state = @State.get
+        state = internal_state
         if completed?(state)
           call_callback method, state, *args
         else
           @Callbacks.push [method, *args]
-          state = @State.get
+          state = internal_state
           # take back if it was completed in the meanwhile
           call_callbacks state if completed?(state)
         end
@@ -760,7 +757,7 @@ module Concurrent
 
       # @!visibility private
       def apply(block)
-        @State.get.apply block
+        internal_state.apply block
       end
 
       private

data/lib/concurrent/edge/lock_free_stack.rb

@@ -26,7 +26,8 @@ module Concurrent
       private(*attr_volatile_with_cas(:head))
 
       def initialize
-        super(EMPTY)
+        super()
+        self.head = EMPTY
       end
 
       def empty?

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre4
+  version: 0.2.0.pre5
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-10-08 00:00:00.000000000 Z
+date: 2015-11-04 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: concurrent-ruby
@@ -18,14 +18,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre4
+        version: 1.0.0.pre5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre4
+        version: 1.0.0.pre5
 description: |
   These features are under active development and may change frequently. They are expected not to
   keep backward compatibility (there may also lack tests and documentation). Semantic versions will