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

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: a4d13aad3839f1bfa159af7cc02464800dd062fb
-  data.tar.gz: 936d530a0a9368d1947339a2d83a6d9f36c979fd
+  metadata.gz: 8589b43e4b23f4d4bb73cddf2123b436e0ea90ba
+  data.tar.gz: baa80cc8ded0dc8a050ce3a64a933183575584a4
 SHA512:
-  metadata.gz: f0fd846fc8ab69642ac313f12e298547ec1958d98c50466ceae1df09df7d047eccea65426fb3c04cb5d4433c933cc73f2ffb60ad81bd4f36a97418c11e58b37d
-  data.tar.gz: d3a92fbc3ebfb09256ba159b4016c0b0caaa371c762ccfb47d01789a09cd8d906f7052f6fa37f2b5c6d7057aff1561f384fe5e032cf25347663a3e93885b0c41
+  metadata.gz: 2c3fbd2d6e8718e62457e39c61bfe95a0da959072af5e05d2162fd12d8aa1aa15137428916766bde9b32f7359f9cab8b21b5883851d5bf432541e1dd531ca719
+  data.tar.gz: a538eca680505fb8b3192fb6a1b5dbcdcc63ac757d56b00bca5745256bd01d007f40d50aad0c4db2df6a33f13e42efe7af384595b3998e9e4c0166094fa5635a

data/README.md

@@ -49,6 +49,14 @@ MRI 1.9.3, 2.0, 2.1, 2.2, JRuby (1.9 mode), and Rubinius 2.x are supported.
 This gem should be fully compatible with any interpreter that is compliant with Ruby 1.9.3 or newer.
 Java 8 is preferred for JRuby but every Java version on which JRuby 9000 runs will be supported.
 
+## Thread Safety
+
+*Concurrent Ruby makes the strongest thread safety guarantees of any Ruby concurrency library. We are the only library with a published [memory model](https://github.com/ruby-concurrency/concurrent-ruby/blob/master/doc/synchronization.md) which provides consistent behavior and guarantees on all three of the main Ruby interpreters (MRI/CRuby, JRuby, and Rubinius).*
+
+Every abstraction in this library is thread safe. Similarly, all are deadlock free and many are fully lock free. Specific thread safety guarantees are documented with each abstraction.
+
+It is critical to remember, however, that Ruby is a language of mutable references. *No* concurrency library for Ruby can ever prevent the user from making thread safety mistakes (such as sharing a mutable object between threads and modifying it on both threads) or from creating deadlocks through incorrect use of locks. All the library can do is provide safe abstractions which encourage safe practices. Concurrent Ruby provides more safe concurrency abstractions than any other Ruby library, many of which support the mantra of ["Do not communicate by sharing memory; instead, share memory by communicating"](https://blog.golang.org/share-memory-by-communicating). Concurrent Ruby is also the only Ruby library which provides a full suite of thread safe and immutable variable types and data structures.
+
 ## Features & Documentation
 
 We have a roadmap guiding our work toward the [v1.0.0 release](https://github.com/ruby-concurrency/concurrent-ruby/issues/257).
@@ -229,39 +237,6 @@ and load the appropriate C extensions.
 No gems should depend on `concurrent-ruby-ext`. Doing so will force C extensions on your users.
 The best practice is to depend on `concurrent-ruby` and let users to decide if they want C extensions.
 
-### Building
-
-All published versions of this gem (core, extension, and several platform-specific packages) are compiled,
-packaged, tested, and published using an open, [automated process](https://github.com/ruby-concurrency/rake-compiler-dev-box).
-This process can also be used to create pre-compiled binaries of the extension gem for virtually
-any platform. *Documentation is forthcoming...*
-
-```
-*MRI only*
-bundle exec rake build:native       # Build concurrent-ruby-ext-<version>-<platform>.gem into the pkg dir
-bundle exec rake compile:extension  # Compile extension
-
-*JRuby only*
-bundle exec rake build              # Build JRuby-specific core gem (alias for `build:core`)
-bundle exec rake build:core         # Build concurrent-ruby-<version>-java.gem into the pkg directory
-
-*All except JRuby*
-bundle exec rake build:core         # Build concurrent-ruby-<version>.gem into the pkg directory
-bundle exec rake build:ext          # Build concurrent-ruby-ext-<version>.gem into the pkg directory
-
-*When Docker IS installed*
-bundle exec rake build:windows      # Build the windows binary <version> gems per rake-compiler-dock
-bundle exec rake build              # Build core, extension, and edge gems, including Windows binaries
-
-*When Docker is NOT installed*
-bundle exec rake build              # Build core, extension, and edge gems (excluding Windows binaries)
-
-*All*
-bundle exec rake clean              # Remove any temporary products
-bundle exec rake clobber            # Remove any generated file
-bundle exec rake compile            # Compile all the extensions
-```
-
 ## Maintainers
 
 * [Jerry D'Antonio](https://github.com/jdantonio) (creator)
@@ -277,14 +252,6 @@ bundle exec rake compile            # Compile all the extensions
 * [Charles Oliver Nutter](https://github.com/headius) for the `atomic` and `thread_safe` gems
 * [thedarkone](https://github.com/thedarkone) for the `thread_safe` gem
 
-## Contributing
-
-1. Fork it
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
-4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
-
 ## License and Copyright
 
 *Concurrent Ruby* is free software released under the [MIT License](http://www.opensource.org/licenses/MIT).

data/lib/concurrent/channel.rb

@@ -8,8 +8,10 @@ module Concurrent
 
   # {include:file:doc/channel.md}
   class Channel
+    extend Forwardable
     include Enumerable
 
+    # NOTE: Move to global IO pool once stable
     GOROUTINES = Concurrent::CachedThreadPool.new
     private_constant :GOROUTINES
 
@@ -32,10 +34,17 @@ module Concurrent
       end
     end
 
+    def_delegators :buffer,
+      :size, :capacity, :close, :closed?,
+      :blocking?, :empty?, :full?
+
+    alias_method :length, :size
+    alias_method :stop, :close
+
     def initialize(opts = {})
       # undocumented -- for internal use only
       if opts.is_a? Buffer::Base
-        @buffer = opts
+        self.buffer = opts
         return
       end
 
@@ -45,25 +54,20 @@ module Concurrent
       if size && buffer == :unbuffered
         raise ArgumentError.new('unbuffered channels cannot have a size')
       elsif size.nil? && buffer.nil?
-        @buffer = BUFFER_TYPES[:unbuffered].new
+        self.buffer = BUFFER_TYPES[:unbuffered].new
       elsif size == 0 && buffer == :buffered
-        @buffer = BUFFER_TYPES[:unbuffered].new
+        self.buffer = BUFFER_TYPES[:unbuffered].new
       elsif buffer == :unbuffered
-        @buffer = BUFFER_TYPES[:unbuffered].new
+        self.buffer = BUFFER_TYPES[:unbuffered].new
       elsif size.nil? || size < 1
         raise ArgumentError.new('size must be at least 1 for this buffer type')
       else
         buffer ||= :buffered
-        @buffer = BUFFER_TYPES[buffer].new(size)
+        self.buffer = BUFFER_TYPES[buffer].new(size)
       end
 
-      @validator = opts.fetch(:validator, DEFAULT_VALIDATOR)
-    end
-
-    def size
-      @buffer.size
+      self.validator = opts.fetch(:validator, DEFAULT_VALIDATOR)
     end
-    alias_method :capacity, :size
 
     def put(item)
       return false unless validate(item, false, false)
@@ -129,22 +133,21 @@ module Concurrent
       item
     end
 
+    # @example
     #
-    #   @example
+    #   jobs = Channel.new
     #
-    #     jobs = Channel.new
-    #
-    #     Channel.go do
-    #       loop do
-    #         j, more = jobs.next
-    #         if more
-    #           print "received job #{j}\n"
-    #         else
-    #           print "received all jobs\n"
-    #           break
-    #         end
+    #   Channel.go do
+    #     loop do
+    #       j, more = jobs.next
+    #       if more
+    #         print "received job #{j}\n"
+    #       else
+    #         print "received all jobs\n"
+    #         break
     #       end
     #     end
+    #   end
     def next
       item, more = do_next
       item = nil if item == Buffer::NO_VALUE
@@ -191,11 +194,6 @@ module Concurrent
       end
     end
 
-    def close
-      @buffer.close
-    end
-    alias_method :stop, :close
-
     class << self
       def timer(seconds)
         Channel.new(Buffer::Timer.new(seconds))
@@ -240,10 +238,12 @@ module Concurrent
 
     private
 
+    attr_accessor :buffer, :validator
+
     def validate(value, allow_nil, raise_error)
       if !allow_nil && value.nil?
         raise_error ? raise(ValidationError.new('nil is not a valid value')) : false
-      elsif !@validator.call(value)
+      elsif !validator.call(value)
         raise_error ? raise(ValidationError) : false
       else
         true
@@ -254,19 +254,19 @@ module Concurrent
     end
 
     def do_put(item)
-      @buffer.put(item)
+      buffer.put(item)
     end
 
     def do_offer(item)
-      @buffer.offer(item)
+      buffer.offer(item)
     end
 
     def do_next
-      @buffer.next
+      buffer.next
     end
 
     def do_poll
-      @buffer.poll
+      buffer.poll
     end
   end
 end

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

@@ -20,19 +20,26 @@ module Concurrent
 
         # @!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
         #   it becomes full.
-        attr_reader :size
-        alias_method :capacity, :size
+        attr_reader :capacity
 
         # @!macro [attach] channel_buffer_initialize
         #
         #   Creates a new buffer.
-        def initialize
+        def initialize(*args)
           super()
           synchronize do
             @closed = false
             @size = 0
+            @capacity = 0
+            @buffer = nil
+            ns_initialize(*args)
           end
         end
 
@@ -187,6 +194,12 @@ module Concurrent
 
         private
 
+        attr_accessor :buffer
+        attr_writer :closed, :capacity, :size
+
+        def ns_initialize(*args)
+        end
+
         # @!macro channel_buffer_closed_question
         def ns_closed?
           @closed

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

@@ -10,20 +10,6 @@ module Concurrent
       # an item is removed from the buffer, creating spare capacity.
       class Buffered < Base
 
-        # @!macro channel_buffer_initialize
-        #
-        # @param [Integer] size the maximum capacity of the buffer; must be
-        #   greater than zero.
-        # @raise [ArgumentError] when the size is zero (0) or less.
-        def initialize(size)
-          raise ArgumentError.new('size must be greater than 0') if size.to_i <= 0
-          super()
-          synchronize do
-            @size = size.to_i
-            @buffer = []
-          end
-        end
-
         # @!macro channel_buffer_empty_question
         def empty?
           synchronize { ns_empty? }
@@ -85,7 +71,7 @@ module Concurrent
               if ns_closed? && ns_empty?
                 return NO_VALUE, false
               elsif !ns_empty?
-                item = @buffer.shift
+                item = buffer.shift
                 more = !ns_empty? || !ns_closed?
                 return item, more
               end
@@ -100,26 +86,37 @@ module Concurrent
             if ns_empty?
               NO_VALUE
             else
-              @buffer.shift
+              buffer.shift
             end
           end
         end
 
         private
 
+        # @!macro channel_buffer_initialize
+        #
+        # @param [Integer] size the maximum capacity of the buffer; must be
+        #   greater than zero.
+        # @raise [ArgumentError] when the size is zero (0) or less.
+        def ns_initialize(size)
+          raise ArgumentError.new('size must be greater than 0') if size.to_i <= 0
+          self.capacity = size.to_i
+          self.buffer = []
+        end
+
         # @!macro channel_buffer_empty_question
         def ns_empty?
-          @buffer.length == 0
+          buffer.length == 0
         end
 
         # @!macro channel_buffer_full_question
         def ns_full?
-          @buffer.length == @size
+          buffer.length == capacity
         end
 
         # @!macro channel_buffer_put
         def ns_put_onto_buffer(item)
-          @buffer.push(item)
+          buffer.push(item)
         end
       end
     end

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

@@ -45,7 +45,7 @@ module Concurrent
 
         # @!macro channel_buffer_put
         def ns_put_onto_buffer(item)
-          @buffer.push(item) unless @buffer.size == size
+          buffer.push(item) unless buffer.size == capacity
         end
       end
     end

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

@@ -45,8 +45,8 @@ module Concurrent
 
         # @!macro channel_buffer_put
         def ns_put_onto_buffer(item)
-          @buffer.shift if @buffer.size == size
-          @buffer.push(item)
+          buffer.shift if buffer.size == capacity
+          buffer.push(item)
         end
       end
     end

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

@@ -8,14 +8,6 @@ module Concurrent
 
       class Ticker < Base
 
-        def initialize(interval)
-          super()
-          synchronize do
-            @interval = interval.to_f
-            @next_tick = Concurrent.monotonic_time + interval
-          end
-        end
-
         def size() 1; end
 
         def empty?() false; end
@@ -63,6 +55,11 @@ module Concurrent
 
         private
 
+        def ns_initialize(interval)
+          @interval = interval.to_f
+          @next_tick = Concurrent.monotonic_time + interval
+        end
+
         def do_poll
           if ns_closed?
             return nil, false

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

@@ -8,15 +8,6 @@ module Concurrent
 
       class Timer < Base
 
-        def initialize(delay)
-          super()
-          synchronize do
-            @tick = Concurrent.monotonic_time + delay.to_f
-            @closed = false
-            @empty = false
-          end
-        end
-
         def size() 1; end
 
         def empty?
@@ -59,13 +50,18 @@ module Concurrent
 
         private
 
+        def ns_initialize(delay)
+          @tick = Concurrent.monotonic_time + delay.to_f
+          @closed = false
+          @empty = false
+        end
+
         def do_poll
           synchronize do
             return :closed, false if ns_closed?
 
             if Concurrent.monotonic_time > @tick
               # only one listener gets notified
-              @closed = @empty = true
               return :tick, Concurrent::Channel::Tick.new(@tick)
             else
               return :wait, true

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

@@ -15,19 +15,8 @@ module Concurrent
       # and the first blocked call will return.
       class Unbuffered < Base
 
-        # @!macro channel_buffer_initialize
-        def initialize
-          super
-          synchronize do
-            # one will always be empty
-            @putting = []
-            @taking = []
-            @closed = false
-          end
-        end
-
         # @!macro channel_buffer_size_reader
-        # 
+        #
         # Always returns zero (0).
         def size() 0; end
 
@@ -54,11 +43,11 @@ module Concurrent
             return false if ns_closed?
 
             ref = Concurrent::AtomicReference.new(item)
-            if @taking.empty?
-              @putting.push(ref)
+            if taking.empty?
+              putting.push(ref)
             else
-              taking = @taking.shift
-              taking.value = item
+              taken = taking.shift
+              taken.value = item
               ref.value = nil
             end
             ref
@@ -78,10 +67,10 @@ module Concurrent
         # buffer is closed, this method will return `false` immediately.
         def offer(item)
           synchronize do
-            return false if ns_closed? || @taking.empty?
+            return false if ns_closed? || taking.empty?
 
-            taking = @taking.shift
-            taking.value = item
+            taken = taking.shift
+            taken.value = item
             true
           end
         end
@@ -96,15 +85,15 @@ module Concurrent
         # and this method will return.
         def take
           mine = synchronize do
-            return NO_VALUE if ns_closed? && @putting.empty?
+            return NO_VALUE if ns_closed? && putting.empty?
 
             ref = Concurrent::AtomicReference.new(nil)
-            if @putting.empty?
-              @taking.push(ref)
+            if putting.empty?
+              taking.push(ref)
             else
-              putting = @putting.shift
-              ref.value = putting.value
-              putting.value = nil
+              put = putting.shift
+              ref.value = put.value
+              put.value = nil
             end
             ref
           end
@@ -124,11 +113,11 @@ module Concurrent
         # buffer is closed, this method will return `NO_VALUE` immediately.
         def poll
           synchronize do
-            return NO_VALUE if @putting.empty?
+            return NO_VALUE if putting.empty?
 
-            putting = @putting.shift
-            value = putting.value
-            putting.value = nil
+            put = putting.shift
+            value = put.value
+            put.value = nil
             value
           end
         end
@@ -142,9 +131,22 @@ module Concurrent
         # @see {#take}
         def next
           item = take
-          more = synchronize { !@putting.empty? }
+          more = synchronize { !putting.empty? }
           return item, more
         end
+
+        private
+
+        attr_accessor :putting, :taking
+
+        # @!macro channel_buffer_initialize
+        def ns_initialize
+          # one will always be empty
+          self.putting = []
+          self.taking = []
+          self.closed = false
+          self.capacity = 1
+        end
       end
     end
   end

data/lib/concurrent/edge/atomic_markable_reference.rb

@@ -11,7 +11,7 @@ module Concurrent
     #   @api Edge
     class AtomicMarkableReference < ::Concurrent::Synchronization::Object
 
-      private *attr_volatile_with_cas(:reference)
+      private(*attr_volatile_with_cas(:reference))
 
       # @!macro [attach] atomic_markable_reference_method_initialize
       def initialize(value = nil, mark = false)

data/lib/concurrent/edge/future.rb

@@ -132,6 +132,7 @@ module Concurrent
     class Event < Synchronization::LockableObject
       safe_initialization!
       include Concern::Deprecation
+      include Concern::Logging
 
       # @!visibility private
       class State
@@ -885,6 +886,7 @@ module Concurrent
     # @!visibility private
     class AbstractPromise < Synchronization::Object
       safe_initialization!
+      include Concern::Logging
 
       def initialize(future)
         super()
@@ -925,7 +927,10 @@ module Concurrent
       # @return [Future]
       def evaluate_to(*args, block)
         complete_with Future::Success.new(block.call(*args))
-      rescue => error
+      rescue StandardError => error
+        complete_with Future::Failed.new(error)
+      rescue Exception => error
+        log(ERROR, 'Edge::Future', error)
         complete_with Future::Failed.new(error)
       end
     end

data/lib/concurrent/edge/lock_free_linked_set.rb

@@ -112,7 +112,7 @@ module Concurrent
           removed = curr.successor_reference.compare_and_set succ, succ, false, true
 
           #next_node unless removed
-          continue unless removed
+          next unless removed
 
           pred.successor_reference.compare_and_set curr, succ, false, false
 

data/lib/concurrent/edge/lock_free_stack.rb

@@ -23,7 +23,7 @@ module Concurrent
 
       EMPTY = Empty[nil, nil]
 
-      private *attr_volatile_with_cas(:head)
+      private(*attr_volatile_with_cas(:head))
 
       def initialize
         super(EMPTY)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: concurrent-ruby-edge
 version: !ruby/object:Gem::Version
-  version: 0.2.0.pre3
+  version: 0.2.0.pre4
 platform: ruby
 authors:
 - Jerry D'Antonio
@@ -10,7 +10,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-09-29 00:00:00.000000000 Z
+date: 2015-10-08 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.pre3
+        version: 1.0.0.pre4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 1.0.0.pre3
+        version: 1.0.0.pre4
 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