celluloid 0.12.4.pre → 0.12.4.pre2

data/lib/celluloid.rb

@@ -24,7 +24,7 @@ module Celluloid
 
     # Are we currently inside of an actor?
     def actor?
-      !!Thread.current[:celluloid_actor]
+      !!Thread.current[:actor]
     end
 
     # Generate a Universally Unique Identifier
@@ -256,7 +256,7 @@ module Celluloid
 
     # Are we being invoked in a different thread from our owner?
     def leaked?
-      @celluloid_owner != Thread.current[:celluloid_actor]
+      @celluloid_owner != Thread.current[:actor]
     end
 
     def inspect
@@ -288,7 +288,7 @@ module Celluloid
 
         call = AsyncCall.new(:__send__, args, block)
         begin
-          Thread.current[:celluloid_actor].mailbox << call
+          Thread.current[:actor].mailbox << call
         rescue MailboxError
           # Silently swallow asynchronous calls to dead actors. There's no way
           # to reliably generate DeadActorErrors for async calls, so users of
@@ -320,17 +320,17 @@ module Celluloid
 
   # Terminate this actor
   def terminate
-    Thread.current[:celluloid_actor].terminate
+    Thread.current[:actor].terminate
   end
 
   # Send a signal with the given name to all waiting methods
   def signal(name, value = nil)
-    Thread.current[:celluloid_actor].signal name, value
+    Thread.current[:actor].signal name, value
   end
 
   # Wait for the given signal
   def wait(name)
-    Thread.current[:celluloid_actor].wait name
+    Thread.current[:actor].wait name
   end
 
   # Obtain the current_actor
@@ -345,12 +345,12 @@ module Celluloid
 
   # Obtain the running tasks for this actor
   def tasks
-    Thread.current[:celluloid_actor].tasks.to_a
+    Thread.current[:actor].tasks.to_a
   end
 
   # Obtain the Celluloid::Links for this actor
   def links
-    Thread.current[:celluloid_actor].links
+    Thread.current[:actor].links
   end
 
   # Watch for exit events from another actor
@@ -385,7 +385,7 @@ module Celluloid
 
   # Receive an asynchronous message via the actor protocol
   def receive(timeout = nil, &block)
-    actor = Thread.current[:celluloid_actor]
+    actor = Thread.current[:actor]
     if actor
       actor.receive(timeout, &block)
     else
@@ -395,7 +395,7 @@ module Celluloid
 
   # Sleep letting the actor continue processing messages
   def sleep(interval)
-    actor = Thread.current[:celluloid_actor]
+    actor = Thread.current[:actor]
     if actor
       actor.sleep(interval)
     else
@@ -406,23 +406,23 @@ module Celluloid
   # Run given block in an exclusive mode: all synchronous calls block the whole
   # actor, not only current message processing.
   def exclusive(&block)
-    Thread.current[:celluloid_actor].exclusive(&block)
+    Thread.current[:actor].exclusive(&block)
   end
 
   # Are we currently exclusive
   def exclusive?
-    actor = Thread.current[:celluloid_actor]
+    actor = Thread.current[:actor]
     actor && actor.exclusive?
   end
 
   # Call a block after a given interval, returning a Celluloid::Timer object
   def after(interval, &block)
-    Thread.current[:celluloid_actor].after(interval, &block)
+    Thread.current[:actor].after(interval, &block)
   end
 
   # Call a block every given interval, returning a Celluloid::Timer object
   def every(interval, &block)
-    Thread.current[:celluloid_actor].every(interval, &block)
+    Thread.current[:actor].every(interval, &block)
   end
 
   # Perform a blocking or computationally intensive action inside an
@@ -437,18 +437,18 @@ module Celluloid
   # Handle async calls within an actor itself
   def async(meth = nil, *args, &block)
     if meth
-      Actor.async Thread.current[:celluloid_actor].mailbox, meth, *args, &block
+      Actor.async Thread.current[:actor].mailbox, meth, *args, &block
     else
-      Thread.current[:celluloid_actor].proxy.async
+      Thread.current[:actor].proxy.async
     end
   end
 
   # Handle calls to future within an actor itself
   def future(meth = nil, *args, &block)
     if meth
-      Actor.future Thread.current[:celluloid_actor].mailbox, meth, *args, &block
+      Actor.future Thread.current[:actor].mailbox, meth, *args, &block
     else
-      Thread.current[:celluloid_actor].proxy.future
+      Thread.current[:actor].proxy.future
     end
   end
 end

data/lib/celluloid/actor.rb

@@ -44,14 +44,14 @@ module Celluloid
 
       # Obtain the current actor
       def current
-        actor = Thread.current[:celluloid_actor]
+        actor = Thread.current[:actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.proxy
       end
 
       # Obtain the name of the current actor
       def name
-        actor = Thread.current[:celluloid_actor]
+        actor = Thread.current[:actor]
         raise NotActorError, "not in actor scope" unless actor
         actor.name
       end
@@ -66,7 +66,7 @@ module Celluloid
           raise DeadActorError, "attempted to call a dead actor"
         end
 
-        if Thread.current[:celluloid_task] && !Celluloid.exclusive?
+        if Thread.current[:task] && !Celluloid.exclusive?
           Task.suspend(:callwait).value
         else
           response = loop do
@@ -74,7 +74,7 @@ module Celluloid
               msg.respond_to?(:call) and msg.call == call
             end
             break message unless message.is_a?(SystemEvent)
-            Thread.current[:celluloid_actor].handle_system_event(message)
+            Thread.current[:actor].handle_system_event(message)
           end
 
           response.value
@@ -104,7 +104,7 @@ module Celluloid
       def all
         actors = []
         Thread.list.each do |t|
-          actor = t[:celluloid_actor]
+          actor = t[:actor]
           actors << actor.proxy if actor and actor.respond_to?(:proxy)
         end
         actors
@@ -113,25 +113,25 @@ module Celluloid
       # Watch for exit events from another actor
       def monitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:celluloid_actor].linking_request(actor, :link)
+        Thread.current[:actor].linking_request(actor, :link)
       end
 
       # Stop waiting for exit events from another actor
       def unmonitor(actor)
         raise NotActorError, "can't link outside actor context" unless Celluloid.actor?
-        Thread.current[:celluloid_actor].linking_request(actor, :unlink)
+        Thread.current[:actor].linking_request(actor, :unlink)
       end
 
       # Link to another actor
       def link(actor)
         monitor actor
-        Thread.current[:celluloid_actor].links << actor
+        Thread.current[:actor].links << actor
       end
 
       # Unlink from another actor
       def unlink(actor)
         unmonitor actor
-        Thread.current[:celluloid_actor].links.delete actor
+        Thread.current[:actor].links.delete actor
       end
 
       # Are we monitoring the given actor?
@@ -141,7 +141,7 @@ module Celluloid
 
       # Are we bidirectionally linked to the given actor?
       def linked_to?(actor)
-        monitoring?(actor) && Thread.current[:celluloid_actor].links.include?(actor)
+        monitoring?(actor) && Thread.current[:actor].links.include?(actor)
       end
 
       # Forcibly kill a given actor
@@ -179,8 +179,8 @@ module Celluloid
       @name      = nil
 
       @thread = ThreadHandle.new do
-        Thread.current[:celluloid_actor]   = self
-        Thread.current[:celluloid_mailbox] = @mailbox
+        Thread.current[:actor]   = self
+        Thread.current[:mailbox] = @mailbox
         run
       end
 
@@ -309,7 +309,7 @@ module Celluloid
 
     # Sleep for the given amount of time
     def sleep(interval)
-      task = Thread.current[:celluloid_task]
+      task = Thread.current[:task]
       if task && !Celluloid.exclusive?
         @timers.after(interval) { task.resume }
         Task.suspend :sleeping
@@ -372,8 +372,8 @@ module Celluloid
       run_finalizer
       cleanup exit_event
     ensure
-      Thread.current[:celluloid_actor]   = nil
-      Thread.current[:celluloid_mailbox] = nil
+      Thread.current[:actor]   = nil
+      Thread.current[:mailbox] = nil
     end
 
     # Run the user-defined finalizer, if one is set

data/lib/celluloid/calls.rb

@@ -13,7 +13,7 @@ module Celluloid
   class SyncCall < Call
     attr_reader :caller, :task
 
-    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:celluloid_task])
+    def initialize(caller, method, arguments = [], block = nil, task = Thread.current[:task])
       super(method, arguments, block)
       @caller = caller
       @task = task

data/lib/celluloid/core_ext.rb

@@ -6,7 +6,7 @@ class Thread
 
   # Retrieve the mailbox for the current thread or lazily initialize it
   def self.mailbox
-    current[:celluloid_mailbox] ||= Celluloid::Mailbox.new
+    current[:mailbox] ||= Celluloid::Mailbox.new
   end
 
   # Receive a message either as an actor or through the local mailbox

data/lib/celluloid/internal_pool.rb

@@ -23,7 +23,7 @@ module Celluloid
             end
           end until thread.status # handle crashed threads
 
-          thread[:celluloid_queue] << block
+          thread[:queue] << block
           thread
         end
       end
@@ -32,7 +32,7 @@ module Celluloid
       def put(thread)
         @mutex.synchronize do
           if @pool.size >= @max_idle
-            thread[:celluloid_queue] << nil
+            thread[:queue] << nil
           else
             @pool << thread
           end
@@ -54,7 +54,7 @@ module Celluloid
           end
         end
 
-        thread[:celluloid_queue] = queue
+        thread[:queue] = queue
         thread
       end
     end

data/lib/celluloid/pool_manager.rb

@@ -93,7 +93,7 @@ module Celluloid
       while @idle.empty?
         # Wait for responses from one of the busy workers
         response = exclusive { receive { |msg| msg.is_a?(Response) } }
-        Thread.current[:celluloid_actor].handle_message(response)
+        Thread.current[:actor].handle_message(response)
       end
 
       worker = @idle.shift

data/lib/celluloid/task.rb

@@ -14,7 +14,7 @@ module Celluloid
 
     # Obtain the current task
     def self.current
-      Thread.current[:celluloid_task] or raise NotTaskError, "not within a task context"
+      Thread.current[:task] or raise NotTaskError, "not within a task context"
     end
 
     # Suspend the running task, deferring to the scheduler

data/lib/celluloid/tasks/task_fiber.rb

@@ -10,14 +10,14 @@ module Celluloid
       @type   = type
       @status = :new
 
-      actor, mailbox = Thread.current[:celluloid_actor], Thread.current[:celluloid_mailbox]
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
       @fiber = Fiber.new do
         @status = :running
-        Thread.current[:celluloid_actor]   = actor
-        Thread.current[:celluloid_mailbox] = mailbox
-        Thread.current[:celluloid_task]    = self
+        Thread.current[:actor]   = actor
+        Thread.current[:mailbox] = mailbox
+        Thread.current[:task]    = self
         actor.tasks << self
 
         begin

data/lib/celluloid/tasks/task_thread.rb

@@ -12,16 +12,16 @@ module Celluloid
       @yield_mutex  = Mutex.new
       @yield_cond   = ConditionVariable.new
 
-      actor, mailbox = Thread.current[:celluloid_actor], Thread.current[:celluloid_mailbox]
+      actor, mailbox = Thread.current[:actor], Thread.current[:mailbox]
       raise NotActorError, "can't create tasks outside of actors" unless actor
 
       @thread = InternalPool.get do
         begin
           unless @resume_queue.pop.is_a?(Task::TerminatedError)
             @status = :running
-            Thread.current[:celluloid_actor]   = actor
-            Thread.current[:celluloid_mailbox] = mailbox
-            Thread.current[:celluloid_task]    = self
+            Thread.current[:actor]   = actor
+            Thread.current[:mailbox] = mailbox
+            Thread.current[:task]    = self
             actor.tasks << self
 
             yield

data/lib/celluloid/version.rb

@@ -1,4 +1,4 @@
 module Celluloid
-  VERSION = '0.12.4.pre'
+  VERSION = '0.12.4.pre2'
   def self.version; VERSION; end
 end

data/spec/support/task_examples.rb

@@ -14,11 +14,11 @@ shared_context "a Celluloid Task" do |task_class|
   subject { task_class.new(task_type) { Celluloid::Task.suspend(suspend_state) } }
 
   before :each do
-    Thread.current[:celluloid_actor] = actor
+    Thread.current[:actor] = actor
   end
 
   after :each do
-    Thread.current[:celluloid_actor] = nil
+    Thread.current[:actor] = nil
   end
 
   it "begins with status :new" do

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.12.4.pre
+  version: 0.12.4.pre2
   prerelease: 7
 platform: ruby
 authors: