celluloid 0.16.0.pre → 0.16.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 3f9e4bf5d8e26e99c5321bc02c61cafa9de48600
-  data.tar.gz: b239f25215d8c3ca0c9c27cd3e08954fa62ee35c
+  metadata.gz: 6b9e9584ba72b44bbb2ce23372b0b4b86f2f3687
+  data.tar.gz: 10ec35b6465a1025defe4a697c3108f1982b5f77
 SHA512:
-  metadata.gz: be0d373d83500400c1135176382097f8bdffeb378fbce48f95852195975984a626221292ade6182ba84cc5a9ca06fa0849461d28c68e9adea33c129396ab39a3
-  data.tar.gz: 6f6cd39aec05a5b8f4b461ad88cd6c960a37d5832ca36ee5f633bf0e3229b294fb714668dcf87d843e162749507c301d14d32d2ae2d344c726b3f55346f9e6c8
+  metadata.gz: 9394c33b6d7eff1efa0e0f78d24ff5578ce208dac695d0b7b806c999b47a456253c670783599ae448cb9bb3f6bf455be4ac66705fb399d8e53c3adb72a894250
+  data.tar.gz: f3e2659328cb38517ec107ad32e7c08d8aaa40fece3d74213273d50f703a6cb0878a43616d933b41fb6d061d928f02ba68850d269be32107062bc5e7b162bcc2

data/README.md

@@ -170,7 +170,3 @@ License
 
 Copyright (c) 2011-2014 Tony Arcieri. Distributed under the MIT License. See
 LICENSE.txt for further details.
-
-
-[![Bitdeli Badge](https://d2weczhvl823v0.cloudfront.net/celluloid/celluloid/trend.png)](https://bitdeli.com/free "Bitdeli Badge")
-

data/lib/celluloid/actor.rb

@@ -1,3 +1,4 @@
+
 require 'timers'
 
 module Celluloid
@@ -111,8 +112,8 @@ module Celluloid
       @tasks     = TaskSet.new
       @links     = Links.new
       @signals   = Signals.new
-      @receivers = Receivers.new
-      @timers    = Timers.new
+      @timers    = Timers::Group.new
+      @receivers = Receivers.new(@timers)
       @handlers  = Handlers.new
       @running   = false
       @name      = nil
@@ -146,11 +147,15 @@ module Celluloid
     def run
       while @running
         begin
-          message = @mailbox.receive(timeout_interval)
-          handle_message message
-        rescue TimeoutError
-          @timers.fire
-          @receivers.fire_timers
+          @timers.wait do |interval|
+            interval = 0 if interval and interval < 0
+            
+            if message = @mailbox.check(interval)
+              handle_message(message)
+
+              break unless @running
+            end
+          end
         rescue MailboxShutdown
           @running = false
         end
@@ -170,31 +175,35 @@ module Celluloid
     # Perform a linking request with another actor
     def linking_request(receiver, type)
       Celluloid.exclusive do
-        start_time = Time.now
         receiver.mailbox << LinkingRequest.new(Actor.current, type)
         system_events = []
 
-        loop do
-          wait_interval = start_time + LINKING_TIMEOUT - Time.now
-          message = @mailbox.receive(wait_interval) do |msg|
-            msg.is_a?(LinkingResponse) &&
-            msg.actor.mailbox.address == receiver.mailbox.address &&
-            msg.type == type
+        Timers::Wait.for(LINKING_TIMEOUT) do |remaining|
+          begin
+            message = @mailbox.receive(remaining) do |msg|
+              msg.is_a?(LinkingResponse) &&
+              msg.actor.mailbox.address == receiver.mailbox.address &&
+              msg.type == type
+            end
+          rescue TimeoutError
+            next # IO reactor did something, no message in queue yet.
           end
 
           if message.instance_of? LinkingResponse
             Celluloid::Probe.actors_linked(self, receiver) if $CELLULOID_MONITORING
+
             # We're done!
             system_events.each { |ev| @mailbox << ev }
+
             return
-          elsif message.instance_of? NilClass
-            raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
-          elsif message.instance_of? SystemEvent
+          elsif message.is_a? SystemEvent
             # Queue up pending system events to be processed after we've successfully linked
             system_events << message
-          else raise 'wtf'
+          else raise "Unexpected message type: #{message.class}. Expected LinkingResponse, NilClass, SystemEvent."
           end
         end
+
+        raise TimeoutError, "linking timeout of #{LINKING_TIMEOUT} seconds exceeded"
       end
     end
 
@@ -222,20 +231,6 @@ module Celluloid
       end
     end
 
-    # How long to wait until the next timer fires
-    def timeout_interval
-      i1 = @timers.wait_interval
-      i2 = @receivers.wait_interval
-
-      if i1 and i2
-        i1 < i2 ? i1 : i2
-      elsif i1
-        i1
-      else
-        i2
-      end
-    end
-
     # Schedule a block to run at the given time
     def after(interval, &block)
       @timers.after(interval) { task(:timer, &block) }

data/lib/celluloid/call_chain.rb

@@ -10,4 +10,4 @@ module Celluloid
       Thread.current[:celluloid_chain_id]
     end
   end
- end
+end

data/lib/celluloid/cpu_counter.rb

@@ -1,26 +1,34 @@
-require 'rbconfig'
-
 module Celluloid
   module CPUCounter
-    case RbConfig::CONFIG['host_os'][/^[A-Za-z]+/]
-    when 'darwin'
-      @cores = Integer(`/usr/sbin/sysctl hw.ncpu`[/\d+/])
-    when 'linux'
-      @cores = if File.exists?("/sys/devices/system/cpu/present")
-        File.read("/sys/devices/system/cpu/present").split('-').last.to_i+1
-      else
-        Dir["/sys/devices/system/cpu/cpu*"].select { |n| n=~/cpu\d+/ }.count
+    class << self
+      def cores
+        @cores ||= count_cores
       end
-    when 'mingw', 'mswin'
-      @cores = Integer(ENV["NUMBER_OF_PROCESSORS"][/\d+/])
-    when 'freebsd'
-      @cores = Integer(`sysctl hw.ncpu`[/\d+/])
-    else
-      @cores = nil
-    end
 
-    def self.cores; @cores; end
-  end
-end
+      private
 
+      def count_cores
+        result = from_env || from_sysdev || from_sysctl
+        Integer(result.to_s[/\d+/], 10) if result
+      end
+
+      def from_env
+        result = ENV['NUMBER_OF_PROCESSORS']
+        result if result
+      end
 
+      def from_sysdev
+        ::IO.read('/sys/devices/system/cpu/present').split('-').last.to_i + 1
+      rescue Errno::ENOENT
+        result = Dir['/sys/devices/system/cpu/cpu*'].count { |n| n =~ /cpu\d+/ }
+        result unless result.zero?
+      end
+
+      def from_sysctl
+        result = `sysctl -n hw.ncpu`
+        result if $?.success?
+      rescue Errno::ENOENT
+      end
+    end
+  end
+end

data/lib/celluloid/evented_mailbox.rb

@@ -37,25 +37,18 @@ module Celluloid
     end
 
     # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
-      message = next_message(block)
-
-      until message
-        if timeout
-          # TODO: use hitimes/timers instead of Time.now
-          now = Time.now
-          wait_until ||= now + timeout
-          wait_interval = wait_until - now
-          raise(TimeoutError, "mailbox timeout exceeded", nil) if wait_interval <= 0
-        else
-          wait_interval = nil
-        end
-
-        @reactor.run_once(wait_interval)
-        message = next_message(block)
+    def check(timeout = nil, &block)
+      # Get a message if it is available and process it immediately if possible:
+      if message = next_message(block)
+        return message
       end
 
-      message
+      # ... otherwise, run the reactor once, either blocking or will return
+      # after the given timeout:
+      @reactor.run_once(timeout)
+
+      # No message was received:
+      return nil
     rescue IOError
       raise MailboxShutdown, "mailbox shutdown called during receive"
     end

data/lib/celluloid/internal_pool.rb

@@ -7,7 +7,10 @@ module Celluloid
 
     def initialize
       @mutex = Mutex.new
-      @threads = []
+      @idle_threads = []
+      @all_threads  = []
+      @busy_size = 0
+      @idle_size = 0
 
       # TODO: should really adjust this based on usage
       @max_idle = 16
@@ -15,17 +18,15 @@ module Celluloid
     end
 
     def busy_size
-      @threads.select(&:busy).size
+      @busy_size
     end
 
     def idle_size
-      @threads.reject(&:busy).size
+      @idle_size
     end
 
     def assert_running
-      unless running?
-        raise Error, "Thread pool is not running"
-      end
+      raise Error, "Thread pool is not running" unless running?
     end
 
     def assert_inactive
@@ -44,17 +45,15 @@ module Celluloid
     end
 
     def active?
-      to_a.any?
+      busy_size + idle_size > 0
     end
 
     def each
-      @threads.each do |thread|
-        yield thread
-      end
+      to_a.each {|thread| yield thread }
     end
 
     def to_a
-      @threads
+      @mutex.synchronize { @all_threads.dup }
     end
 
     # Get a thread from the pool, running the given block
@@ -63,15 +62,16 @@ module Celluloid
         assert_running
 
         begin
-          idle = @threads.reject(&:busy)
-          if idle.empty?
+          if @idle_threads.empty?
             thread = create
           else
-            thread = idle.first
+            thread = @idle_threads.pop
+            @idle_size = @idle_threads.length
           end
         end until thread.status # handle crashed threads
 
         thread.busy = true
+        @busy_size += 1
         thread[:celluloid_queue] << block
         thread
       end
@@ -81,15 +81,46 @@ module Celluloid
     def put(thread)
       @mutex.synchronize do
         thread.busy = false
-        if idle_size >= @max_idle
+        if idle_size + 1 >= @max_idle
           thread[:celluloid_queue] << nil
-          @threads.delete(thread)
+          @busy_size -= 1
+          @all_threads.delete(thread)
         else
+          @idle_threads.push thread
+          @busy_size -= 1
+          @idle_size = @idle_threads.length
           clean_thread_locals(thread)
         end
       end
     end
 
+    def shutdown
+      @mutex.synchronize do
+        finalize
+        @all_threads.each do |thread|
+          thread[:celluloid_queue] << nil
+        end
+        @all_threads.clear
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    def kill
+      @mutex.synchronize do
+        finalize
+        @running = false
+
+        @all_threads.shift.kill until @all_threads.empty?
+        @idle_threads.clear
+        @busy_size = 0
+        @idle_size = 0
+      end
+    end
+
+    private
+
     # Create a new thread with an associated queue of procs to run
     def create
       queue = Queue.new
@@ -106,7 +137,8 @@ module Celluloid
       end
 
       thread[:celluloid_queue] = queue
-      @threads << thread
+      # @idle_threads << thread
+      @all_threads << thread
       thread
     end
 
@@ -120,26 +152,6 @@ module Celluloid
       end
     end
 
-    def shutdown
-      @mutex.synchronize do
-        finalize
-        @threads.each do |thread|
-          thread[:celluloid_queue] << nil
-        end
-      end
-    end
-
-    def kill
-      @mutex.synchronize do
-        finalize
-        @running = false
-
-        @threads.shift.kill until @threads.empty?
-      end
-    end
-
-    private
-
     def finalize
       @max_idle = 0
     end

data/lib/celluloid/mailbox.rb

@@ -45,36 +45,39 @@ module Celluloid
       end
     end
 
-    # Receive a message from the Mailbox
-    def receive(timeout = nil, &block)
+    # Receive a message from the Mailbox. May return nil and may return before
+    # the specified timeout.
+    def check(timeout = nil, &block)
       message = nil
 
       @mutex.lock
       begin
         raise MailboxDead, "attempted to receive from a dead mailbox" if @dead
 
-        begin
+        Timers::Wait.for(timeout) do |remaining|
           message = next_message(&block)
 
-          unless message
-            if timeout
-              # TODO: use hitimes/timers instead of Time.now
-              now = Time.now
-              wait_until ||= now + timeout
-              wait_interval = wait_until - now
-              raise(TimeoutError, "mailbox timeout exceeded", nil) if wait_interval <= 0
-            else
-              wait_interval = nil
-            end
-
-            @condition.wait(@mutex, wait_interval)
-          end
-        end until message
-
-        message
+          break message if message
+
+          @condition.wait(@mutex, remaining)
+        end
       ensure
         @mutex.unlock rescue nil
       end
+      
+      return message
+    end
+
+    # Receive a letter from the mailbox. Guaranteed to return a message. If
+    # timeout is exceeded, raise a TimeoutError.
+    def receive(timeout = nil, &block)
+      Timers::Wait.for(timeout) do |remaining|
+        if message = check(timeout, &block)
+          return message
+        end
+      end
+      
+      raise TimeoutError.new("receive timeout exceeded")
     end
 
     # Shut down this mailbox and clean up its contents

data/lib/celluloid/pool_manager.rb

@@ -24,7 +24,7 @@ module Celluloid
     end
 
     def __shutdown__
-      terminators = (@idle + @busy).each do |actor|
+      terminators = (@idle + @busy).map do |actor|
         begin
           actor.future(:terminate)
         rescue DeadActorError
@@ -81,6 +81,23 @@ module Celluloid
       @size
     end
 
+    def size=(new_size)
+      new_size = [0, new_size].max
+
+      if new_size > size
+        delta = new_size - size
+        delta.times { @idle << @worker_class.new_link(*@args) }
+      else
+        (size - new_size).times do
+          worker = __provision_worker__
+          unlink worker
+          @busy.delete worker
+          worker.terminate
+        end
+      end
+      @size = new_size
+    end
+
     def busy_size
       @busy.length
     end

data/lib/celluloid/receivers.rb

@@ -1,12 +1,13 @@
 require 'set'
+
 require 'timers'
 
 module Celluloid
   # Allow methods to directly interact with the actor protocol
   class Receivers
-    def initialize
+    def initialize(timers)
       @receivers = Set.new
-      @timers = Timers.new
+      @timers = timers
     end
 
     # Receive an asynchronous message
@@ -28,23 +29,13 @@ module Celluloid
       end
     end
 
-    # How long to wait until the next timer fires
-    def wait_interval
-      @timers.wait_interval
-    end
-
-    # Fire any pending timers
-    def fire_timers
-      @timers.fire
-    end
-
     # Handle incoming messages
     def handle_message(message)
       receiver = @receivers.find { |r| r.match(message) }
       return unless receiver
 
       @receivers.delete receiver
-      @timers.cancel receiver.timer if receiver.timer
+      receiver.timer.cancel if receiver.timer
       receiver.resume message
       message
     end

data/{spec/support → lib/celluloid/rspec}/actor_examples.rb

@@ -285,6 +285,31 @@ shared_examples "Celluloid::Actor examples" do |included_module, task_klass|
     actor.send('foo').should eq('oof')
   end
 
+  context "when executing under JRuby" do
+    let(:klass) {
+      Class.new do
+        include included_module
+        task_class task_klass
+
+        def current_thread_name
+          java_thread.get_name
+        end
+
+        def java_thread
+          Thread.current.to_java.getNativeThread
+        end
+      end
+    }
+
+    it "sets execution info" do
+      klass.new.current_thread_name.should == "Class#current_thread_name"
+    end
+
+    it "unsets execution info after task completion" do
+      klass.new.java_thread.get_name.should == "<unused>"
+    end
+  end if RUBY_PLATFORM == "java"
+
   context "mocking methods" do
     let(:actor) { actor_class.new "Troy McClure" }
 

data/lib/celluloid/rspec.rb

@@ -1,6 +1,7 @@
-require File.expand_path('../../../spec/support/example_actor_class', __FILE__)
-require File.expand_path('../../../spec/support/actor_examples', __FILE__)
-require File.expand_path('../../../spec/support/mailbox_examples', __FILE__)
+require 'celluloid/rspec/example_actor_class'
+require 'celluloid/rspec/actor_examples'
+require 'celluloid/rspec/mailbox_examples'
+require 'celluloid/rspec/task_examples'
 
 module Celluloid
   # Timer accuracy enforced by the tests (50ms)

data/lib/celluloid/tasks/task_fiber.rb

@@ -37,7 +37,7 @@ module Celluloid
     end
 
     def backtrace
-      "#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."
+      ["#{self.class} backtrace unavailable. Please try `Celluloid.task_class = Celluloid::TaskThread` if you need backtraces here."]
     end
   end
 end

data/lib/celluloid/tasks.rb

@@ -48,6 +48,8 @@ module Celluloid
           @status = :running
           actor.setup_thread
 
+          name_current_thread thread_metadata
+
           Thread.current[:celluloid_task] = self
           CallChain.current_id = @chain_id
 
@@ -56,6 +58,7 @@ module Celluloid
         rescue Task::TerminatedError
           # Task was explicitly terminated
         ensure
+          name_current_thread nil
           @status = :dead
           actor.tasks.delete self
         end
@@ -147,6 +150,25 @@ module Celluloid
         raise message if $CELLULOID_DEBUG
       end
     end
+
+    private
+
+    def name_current_thread(new_name)
+      return unless RUBY_PLATFORM == "java"
+      if new_name.nil?
+        new_name = Thread.current[:celluloid_original_thread_name]
+        Thread.current[:celluloid_original_thread_name] = nil
+      else
+        Thread.current[:celluloid_original_thread_name] = Thread.current.to_java.getNativeThread.get_name
+      end
+      Thread.current.to_java.getNativeThread.set_name(new_name)
+    end
+
+    def thread_metadata
+      method = @meta && @meta[:method_name] || "<no method>"
+      klass = Thread.current[:celluloid_actor] && Thread.current[:celluloid_actor].behavior.subject.bare_object.class || "<no actor>"
+      format("[Celluloid] %s#%s", klass, method)
+    end
   end
 end
 

data/lib/celluloid.rb

@@ -7,7 +7,7 @@ module Celluloid
   # Expose all instance methods as singleton methods
   extend self
 
-  VERSION = '0.16.0.pre'
+  VERSION = '0.16.0'
 
   # Linking times out after 5 seconds
   LINKING_TIMEOUT = 5

data/spec/celluloid/cpu_counter_spec.rb

@@ -2,8 +2,81 @@ require 'spec_helper'
 
 describe Celluloid::CPUCounter do
   describe :cores do
-    it 'should return an integer' do
-      Celluloid::CPUCounter.cores.should be_kind_of(Fixnum)
+    subject { described_class.cores }
+
+    let(:num_cores) { 1024 }
+
+    before do
+      described_class.stub(:`) { fail 'backtick stub called' }
+      ::IO.stub(:open).and_raise('IO.open stub called!')
+      described_class.instance_variable_set('@cores', nil)
+    end
+
+    after { ENV['NUMBER_OF_PROCESSORS'] = nil }
+
+    context 'from valid env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = num_cores.to_s }
+      it { should eq num_cores }
+    end
+
+    context 'from invalid env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = '' }
+      specify { expect { subject }.to raise_error(ArgumentError) }
+    end
+
+    context 'with no env value' do
+      before { ENV['NUMBER_OF_PROCESSORS'] = nil }
+
+      context 'when /sys/devices/system/cpu/present exists' do
+        before do
+          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
+            .and_return("dunno-whatever-#{num_cores - 1}")
+        end
+        it { should eq num_cores }
+      end
+
+      context 'when /sys/devices/system/cpu/present does NOT exist' do
+        before do
+          ::IO.should_receive(:read).with('/sys/devices/system/cpu/present')
+            .and_raise(Errno::ENOENT)
+        end
+
+        context 'when /sys/devices/system/cpu/cpu* files exist' do
+          before do
+            cpu_entries = (1..num_cores).map { |n| "cpu#{n}" }
+            cpu_entries << 'non-cpu-entry-to-ignore'
+            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
+              .and_return(cpu_entries)
+          end
+          it { should eq num_cores }
+        end
+
+        context 'when /sys/devices/system/cpu/cpu* files DO NOT exist' do
+          before do
+            Dir.should_receive(:[]).with('/sys/devices/system/cpu/cpu*')
+              .and_return([])
+          end
+
+          context 'when sysctl blows up' do
+            before { described_class.stub(:`).and_raise(Errno::EINTR) }
+            specify { expect { subject }.to raise_error }
+          end
+
+          context 'when sysctl fails' do
+            before { described_class.stub(:`).and_return(`false`) }
+            it { should be nil }
+          end
+
+          context 'when sysctl succeeds' do
+            before do
+              described_class.should_receive(:`).with('sysctl -n hw.ncpu')
+                .and_return(num_cores.to_s)
+              `true`
+            end
+            it { should eq num_cores }
+          end
+        end
+      end
     end
   end
 end

data/spec/celluloid/pool_spec.rb

@@ -14,11 +14,23 @@ describe "Celluloid.pool", actor_system: :global do
       end
     end
 
+    def sleepy_work
+      t = Time.now.to_f
+      sleep 0.25
+      t
+    end
+
     def crash
       raise ExampleError, "zomgcrash"
     end
   end
 
+  def test_concurrency_of(pool)
+    baseline = Time.now.to_f
+    values = 10.times.map { pool.future.sleepy_work }.map(&:value)
+    values.select {|t| t - baseline < 0.1 }.length
+  end
+
   subject { MyWorker.pool }
 
   it "processes work units synchronously" do
@@ -56,4 +68,25 @@ describe "Celluloid.pool", actor_system: :global do
     end
     futures.map(&:value)
   end
+
+  context "#size=" do
+    subject { MyWorker.pool size: 4 }
+
+    it "should adjust the pool size up", pending: 'flaky' do
+      expect(test_concurrency_of(subject)).to eq(4)
+
+      subject.size = 6
+      subject.size.should == 6
+
+      test_concurrency_of(subject).should == 6
+    end
+
+    it "should adjust the pool size down" do
+      test_concurrency_of(subject).should == 4
+
+      subject.size = 2
+      subject.size.should == 2
+      test_concurrency_of(subject).should == 2
+    end
+  end
 end

data/spec/celluloid/stack_dump_spec.rb

@@ -45,8 +45,8 @@ describe Celluloid::StackDump do
   end
 
   describe '#threads' do
-    it 'should include threads that are not actors' do
-      subject.threads.size.should == 3
+    it 'should include threads that are not actors', pending: 'flaky' do
+      expect(subject.threads.size).to eq(3)
     end
 
     it 'should include idle threads' do
@@ -57,8 +57,8 @@ describe Celluloid::StackDump do
       subject.threads.map(&:thread_id).should include(@active_thread.object_id)
     end
 
-    it 'should have the correct roles' do
-      subject.threads.map(&:role).should include(nil, :other_thing, :task)
+    it 'should have the correct roles', pending: 'flaky' do
+      expect(subject.threads.map(&:role)).to include(nil, :other_thing, :task)
     end
   end
 end

data/spec/celluloid/timer_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+
+class EveryActor
+  include Celluloid
+
+  def initialize
+    @trace = []
+    @times = []
+    @start = Time.now
+    
+    every(1) { log(1) }
+    every(2) { log(2) }
+    every(1) { log(11) }
+    every(2) { log(22) }
+  end
+  
+  def log(t)
+    @trace << t
+    
+    offset = Time.now - @start
+    @times << offset
+    
+    # puts "log(#{t}) @ #{offset}"
+  end
+  
+  attr :trace
+  attr :times
+end
+
+describe Celluloid::Actor do
+  it "run every(t) task several times" do
+    Celluloid.boot
+    
+    every_actor = EveryActor.new
+    
+    sleep 5.5
+    
+    times = every_actor.times
+    trace = every_actor.trace
+    
+    Celluloid.shutdown
+    
+    expect(trace.count(1)).to be == 5
+    expect(trace.count(11)).to be == 5
+    expect(trace.count(2)).to be == 2
+    expect(trace.count(22)).to be == 2
+  end
+end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.16.0.pre
+  version: 0.16.0
 platform: ruby
 authors:
 - Tony Arcieri
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-03-29 00:00:00.000000000 Z
+date: 2014-09-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -16,14 +16,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 4.0.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 2.0.0
+        version: 4.0.0
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -80,6 +80,20 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Celluloid enables people to build concurrent programs out of concurrent
   objects just as easily as they build sequential programs out of sequential objects
 email:
@@ -133,6 +147,10 @@ files:
 - lib/celluloid/registry.rb
 - lib/celluloid/responses.rb
 - lib/celluloid/rspec.rb
+- lib/celluloid/rspec/actor_examples.rb
+- lib/celluloid/rspec/example_actor_class.rb
+- lib/celluloid/rspec/mailbox_examples.rb
+- lib/celluloid/rspec/task_examples.rb
 - lib/celluloid/signals.rb
 - lib/celluloid/stack_dump.rb
 - lib/celluloid/supervision_group.rb
@@ -170,12 +188,9 @@ files:
 - spec/celluloid/tasks/task_fiber_spec.rb
 - spec/celluloid/tasks/task_thread_spec.rb
 - spec/celluloid/thread_handle_spec.rb
+- spec/celluloid/timer_spec.rb
 - spec/celluloid/uuid_spec.rb
 - spec/spec_helper.rb
-- spec/support/actor_examples.rb
-- spec/support/example_actor_class.rb
-- spec/support/mailbox_examples.rb
-- spec/support/task_examples.rb
 homepage: https://github.com/celluloid/celluloid
 licenses:
 - MIT
@@ -196,7 +211,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: 1.3.6
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.2.0
+rubygems_version: 2.2.2
 signing_key: 
 specification_version: 4
 summary: Actor-based concurrent object framework for Ruby