Thread local propagation

.document

@@ -1,5 +1,5 @@
 lib/**/*.rb
 bin/*
-- 
+-
 features/**/*.feature
 LICENSE.txt

.rspec

@@ -1,4 +1,4 @@
---color 
---format documentation 
+--color
+--format documentation
 --backtrace
 --default_path spec

.travis.yml

@@ -1,8 +1,11 @@
+script: rake ci
+bundler_args: --without custom
 rvm:
-  - 1.9.2
   - 1.9.3
   - ruby-head
   - jruby-19mode
   - jruby-head
-  - rbx-18mode
-  - rbx-19mode
+  - rbx-19mode 
+
+notifications:
+  irc: "irc.freenode.org#celluloid"

CHANGES.md

@@ -1,3 +1,87 @@
+0.12.3
+------
+* Bugfix: Ensure exclusive mode works correctly for per-method case
+* Bugfix: Exit handlers were not being inherited correctly
+
+0.12.2
+------
+* Disable IncidentReporter by default
+
+0.12.1
+------
+* Fix bug in unsetting of exclusive mode
+* New incident report system for providing better debugging reports
+* Revert BasicObject proxies for now... they are causing problems
+* String inspect that reveals bare object leaks
+* Fix bug reporting proper task statuses
+* Initial thread dumper support
+* Remove Celluloid#alive? as it cannot be called in any manner that will ever
+  return anything but true, rendering it useless
+* Use Facter to get CPU count
+
+0.12.0
+------
+* Alternative async syntax: actor.async.method in lieu of actor.method!
+  Original syntax still available but will be removed in Celluloid 1.0
+* Alternative future syntax: actor.future.method in lieu of future(:method)
+* All methods in the Celluloid module are now available on its singleton
+* The #join and #kill methods are no longer available on the actor proxy.
+  Please use Celluloid::Actor.join(actor) and .kill(actor) instead.
+* Celluloid::Future#ready? can be used to query for future readiness
+* Celluloid::Group constant removed. Please use Celluloid::SupervisionGroup
+* #monitor, #unmonitor, and #monitoring? provide unidirectional linking
+* Linking is now performed via a SystemEvent
+* SystemEvents are no longer exceptions. Boo exceptions as flow control!
+* Celluloid::Mailbox#system_event eliminated and replaced with Mailbox#<<
+  SystemEvents are now automatically high priority
+* The task_class class method can be used to override the class used for
+  tasks, allowing different task implementations to be configured on an
+  actor-by-actor-basis
+* Celluloid::TaskThread provides tasks backed by Threads instead of Fibers
+* ActorProxy is now a BasicObject
+* A bug prevented Celluloid subclasses from retaining custom mailboxes
+  defined by use_mailbox. This is now fixed.
+* `exclusive` class method without arguments makes the whole actor exclusive
+
+0.11.1
+------
+* 'exclusive' class method marks methods as always exclusive and runs them
+  outside of a Fiber (useful if you need more stack than Fibers provide)
+* Celluloid::PoolManager returns its own class when #class is called, instead
+  of proxying to a cell/actor in the pool.
+* #receive now handles SystemEvents internally
+* Celluloid::Timers extracted into the timers gem, which Celluloid now
+  uses for its own timers
+
+0.11.0
+------
+* Celluloid::Application constant permanently removed
+* Celluloid::Pool removed in favor of Celluloid.pool
+* Celluloid::Group renamed to Celluloid::SupervisionGroup, old name is
+  still available and has not been deprecated
+* Celluloid::ThreadPool renamed to Celluloid::InternalPool to emphasize its
+  internalness
+* Support for asynchronously calling private methods inside actors
+* Future is now an instance method on all actors
+* Async call exception logs now contain the failed method
+* MyActor#async makes async calls for those who dislike the predicate syntax
+* abort can now accept a string instead of an exception object and will raise
+  RuntimeError in the caller's context
+
+0.10.0
+------
+* Celluloid::Actor.current is now the de facto way to obtain the current actor
+* #terminate now uses system messages, making termination take priority over
+  other pending methods
+* #terminate! provides asynchronous termination
+
+0.9.1
+-----
+* Recurring timers with Celluloid#every(n) { ... }
+* Obtain UUIDs with Celluloid.uuid
+* Obtain the number of CPU cores available with Celluloid.cores
+* Celluloid::Pool defaults to one actor per CPU core max by default
+
 0.9.0
 -----
 * Celluloid::Pool supervises pools of actors

Gemfile

@@ -1,5 +1,10 @@
 source :rubygems
+gemspec
 
-gem 'ffi', :platform => :mri
+if RUBY_PLATFORM =~ /darwin/
+  gem 'rb-fsevent', '~> 0.9.1'
+end
 
-gemspec
+group :custom do
+  gem 'guard-rspec'
+end

Guardfile

@@ -0,0 +1,5 @@
+guard 'rspec', :version => 2, :cli => '--format documentation' do
+  watch(%r{^spec/.+_spec\.rb$})
+  watch(%r{^lib/(.+)\.rb$})     { |m| "spec/#{m[1]}_spec.rb" }
+  watch('spec/spec_helper.rb')  { "spec/" }
+end

README.md

@@ -1,4 +1,4 @@
-![Celluloid](https://github.com/celluloid/celluloid/raw/master/logo.png)
+![Celluloid](https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png)
 =========
 [![Build Status](https://secure.travis-ci.org/celluloid/celluloid.png?branch=master)](http://travis-ci.org/celluloid/celluloid)
 [![Dependency Status](https://gemnasium.com/celluloid/celluloid.png)](https://gemnasium.com/celluloid/celluloid)
@@ -17,7 +17,7 @@ Much of the difficulty with building concurrent programs in Ruby arises because
 the object-oriented mechanisms for structuring code, such as classes and
 inheritance, are separate from the concurrency mechanisms, such as threads and
 locks. Celluloid combines these into a single structure, an active object
-running within a thread, called an "actor".
+running within a thread, called an "actor", or in Celluloid vernacular, a "cell".
 
 By combining concurrency with object oriented programming, Celluloid frees you
 up from worry about where to use threads and locks. Celluloid combines them
@@ -50,7 +50,7 @@ features which make concurrent programming simple, easy, and fun:
   a clean state. Celluloid provides its own implementation of the core
   fault-tolerance concepts in Erlang including [linking](https://github.com/celluloid/celluloid/wiki/Linking),
   [supervisors](https://github.com/celluloid/celluloid/wiki/Supervisors),
-  and [supervision trees](https://github.com/celluloid/celluloid/wiki/Groups).
+  and [supervision groups](https://github.com/celluloid/celluloid/wiki/Supervision-Groups).
 
 * __[Futures](https://github.com/celluloid/celluloid/wiki/futures):__
   Ever wanted to call a method "in the background" and retrieve the
@@ -63,27 +63,65 @@ features which make concurrent programming simple, easy, and fun:
 
 You can also build distributed systems with Celluloid using its
 [sister project DCell](https://github.com/celluloid/dcell). Evented IO similar
-to EventMachine (with a synchronous API) is available through the
-[Celluloid::IO](https://github.com/celluloid/celluloid-io) library.
+to EventMachine (with a synchronous API instead of callback/deferrable soup)
+is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
+library.
+
+Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
+or visit us on IRC at #celluloid on freenode
+
+### Is It "Production Ready™"?
+
+Yes, many users are now running Celluloid in production by using
+[Sidekiq](http://sidekiq.org) and [Adhearsion](http://adhearsion.com/)
+
+Documentation
+-------------
 
 [Please see the Celluloid Wiki](https://github.com/celluloid/celluloid/wiki)
 for more detailed documentation and usage notes.
 
-Like Celluloid? [Join the Google Group](http://groups.google.com/group/celluloid-ruby)
-or visit us on IRC at #celluloid on freenode
+The following API documentation is also available:
+
+* [YARD API documentation](http://rubydoc.info/gems/celluloid/frames)
+* [Celluloid module (primary API)](http://rubydoc.info/gems/celluloid/Celluloid)
+* [Celluloid class methods](http://rubydoc.info/gems/celluloid/Celluloid/ClassMethods)
+* [All Celluloid classes](http://rubydoc.info/gems/celluloid/index)
+
+Installation
+------------
+
+Add this line to your application's Gemfile:
+
+    gem 'celluloid'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install celluloid
+
+Inside of your Ruby program do:
+
+    require 'celluloid'
+
+...to pull it in as a dependency.
 
 Supported Platforms
 -------------------
 
-Celluloid works on Ruby 1.9.2+, JRuby 1.6 (in 1.9 mode), and Rubinius 2.0. JRuby
-or Rubinius are the preferred platforms as they support true hardware-level
-parallelism when running Ruby code, whereas MRI/YARV is constrained by a global
-interpreter lock (GIL).
+Celluloid works on Ruby 1.9.3, JRuby 1.6, and Rubinius 2.0. JRuby or Rubinius
+are the preferred platforms as they support true thread-level parallelism when
+executing Ruby code, whereas MRI/YARV is constrained by a global interpreter
+lock (GIL) and can only execute one thread at a time.
 
-To use JRuby in 1.9 mode, you'll need to pass the "--1.9" command line option
-to the JRuby executable, or set the "JRUBY_OPTS=--1.9" environment variable.
+Celluloid requires Ruby 1.9 mode on all interpreters. This works out of the
+box on MRI/YARV, and requires the following flags elsewhere:
 
-Celluloid works on Rubinius in either 1.8 or 1.9 mode.
+* JRuby: --1.9 command line option, or JRUBY_OPTS=--1.9 environment variable
+* rbx: -X19 command line option
 
 Additional Reading
 ------------------

Rakefile

@@ -1,4 +1,5 @@
 require "bundler/gem_tasks"
 Dir["tasks/**/*.task"].each { |task| load task }
 
-task :default => %w(spec benchmark)
+task :default => :spec
+task :ci      => %w(spec benchmark)

benchmarks/actor.rb

@@ -26,10 +26,10 @@ def example_method; end
   ips.report("spawn")       { ExampleActor.new.terminate }
   ips.report("calls")       { example_actor.example_method }
   ips.report("async calls") { example_actor.example_method! }
-  
+
   ips.report("messages") do |n|
     latch_in << n
     for i in 0..n; mailbox << :message; end
     latch_out.pop
   end
-end
+end

benchmarks/parallel_hash.rb

@@ -0,0 +1,15 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid'
+require 'benchmark/ips'
+require File.expand_path("../../examples/pool", __FILE__)
+
+pool = Rehasher.new
+
+Benchmark.ips do |ips|
+  ips.report("parallel hash") do
+    64.times.map { pool.future(:rehash, 'w3rd', 10_000) }.map(&:value)
+  end
+end

benchmarks/uuid.rb

@@ -0,0 +1,10 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+require 'bundler/setup'
+require 'celluloid'
+require 'benchmark/ips'
+
+Benchmark.ips do |ips|
+  ips.report("uuid") { Celluloid.uuid }
+end

celluloid.gemspec

@@ -13,12 +13,16 @@ Gem::Specification.new do |gem|
   gem.authors     = ['Tony Arcieri']
   gem.email       = ['tony.arcieri@gmail.com']
   gem.homepage    = 'https://github.com/celluloid/celluloid'
-
+
+  gem.required_ruby_version     = '>= 1.9.2'
   gem.required_rubygems_version = '>= 1.3.6'
-  
+
   gem.files        = Dir['README.md', 'lib/**/*', 'spec/support/**/*']
   gem.require_path = 'lib'
 
+  gem.add_runtime_dependency 'timers', '>= 1.0.0'
+  gem.add_runtime_dependency 'facter', '>= 1.6.12'
+
   gem.add_development_dependency 'rake'
   gem.add_development_dependency 'rspec'
   gem.add_development_dependency 'benchmark_suite'

examples/basic_usage.rb

@@ -30,12 +30,12 @@ def increment(n = 1)
 # This increments @count by 1 and prints 1
 p actor.increment
 
-# Adding ! to the end of any method makes the call asynchronous. This means a
-# request to execute the method will be sent to an actor, and we have no idea
+# By using actor.async, you can make calls asynchronously. This immediately
+# requests execution of method by sending a message, and we have no idea
 # whether or not that request will actually complete because we don't wait
 # for a response. Async calls immediately return nil regardless of how long
 # the method takes to execute. Therefore, this will print nil.
-p actor.increment! 41
+p actor.async.increment 41
 
 # In practice, the asynchronous call made above will increment the count before
 # we get here. However, do not rely on this behavior! Asynchronous methods are

examples/cigarette_smokers.rb

@@ -91,8 +91,8 @@ def inspect
   def sit(table)
     puts "#{name} sits down at table"
 
-    # DON'T USE SELF ACROSS ACTORS!
-    table.smokers << current_actor
+    # Always use Actor.current instead of self when talking to other actors
+    table.smokers << Actor.current
     @table = table
 
     @machine.transition :procuring
@@ -116,7 +116,7 @@ def notify_ready
   def check_table
     if @table.empty?
       puts "#{name} whistles at waitress... get me smokes!"
-      @table.waitress.whistle! # We'll decide what to do when the waitress arrives
+      @table.waitress.async.whistle # We'll decide what to do when the waitress arrives
     end
   end
 
@@ -137,7 +137,7 @@ def take_items
     items = @table.take
 
     puts "#{name} whistles for the waitress because the table is empty"
-    @table.waitress.whistle!
+    @table.waitress.async.whistle
 
     tobacco = find_item items, Tobacco
     paper   = find_item items, Paper
@@ -214,7 +214,7 @@ def refill_table
     end
 
     puts "Waitress tells #{receiver.name} he can smoke now"
-    receiver.notify_ready!
+    receiver.async.notify_ready
     note_smokers
   end
 
@@ -234,7 +234,7 @@ class Table
 
   def initialize
     @smokers = []
-    @waitress = Waitress.new(current_actor) # DON'T USE SELF!
+    @waitress = Waitress.new(Actor.current) # Always use Actor.current instead of self!
     @items = nil
   end
 

examples/futures.rb

@@ -27,7 +27,7 @@ def add(data, n = 100000)
 
 # Ask the hasher to perform a complex computation. However, since we're using
 # a future, this doesn't block the current thread
-future = hasher.future(:add, "some data to be hashed")
+future = hasher.future.add("some data to be hashed")
 
 # We've kicked off the hasher, but this thread can continue performing other
 # activities while the hasher runs in the background