celluloid 0.0.1

data/.autotest

@@ -0,0 +1,14 @@
+require 'autotest/rspec2'
+
+Autotest.add_hook :initialize do |autotest|
+  autotest.add_exception '.git'
+  autotest.clear_mappings
+  
+  # Map specs to themselves
+  autotest.add_mapping(%r<^spec/.*_spec.rb$>) { |file, _| file }
+
+  # Map libraries to specs
+  autotest.add_mapping(%r<lib/celluloid/(.*).rb$>) do |_, m|
+    ["spec/#{m[1]}_spec.rb"]
+  end
+end

data/.document

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

data/.rspec

@@ -0,0 +1,3 @@
+--color 
+--format documentation 
+--backtrace

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in celluloid.gemspec
+gemspec

data/Gemfile.lock

@@ -0,0 +1,34 @@
+PATH
+  remote: .
+  specs:
+    celluloid (0.0.1)
+      celluloid
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    diff-lcs (1.1.2)
+    git (1.2.5)
+    jeweler (1.5.2)
+      bundler (~> 1.0.0)
+      git (>= 1.2.5)
+      rake
+    rake (0.8.7)
+    rspec (2.5.0)
+      rspec-core (~> 2.5.0)
+      rspec-expectations (~> 2.5.0)
+      rspec-mocks (~> 2.5.0)
+    rspec-core (2.5.1)
+    rspec-expectations (2.5.0)
+      diff-lcs (~> 1.1.2)
+    rspec-mocks (2.5.0)
+
+PLATFORMS
+  java
+  ruby
+
+DEPENDENCIES
+  bundler (~> 1.0.0)
+  celluloid!
+  jeweler (~> 1.5.2)
+  rspec (>= 2.3.0)

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2011 Tony Arcieri
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,286 @@
+Celluloid
+=========
+
+> "I thought of objects being like biological cells and/or individual 
+> computers on a network, only able to communicate with messages"  
+> _--Alan Kay, creator of Smalltalk, on the meaning of "object oriented programming"_
+
+Celluloid is a concurrent object framework for Ruby inspired by Erlang and the
+Actor model. Celluloid gives you thread-backed objects that run concurrently,
+providing the simplicity of Ruby objects for the most common use cases, but
+also the ability to call methods _asynchronously_, allowing the receiver to do
+things in the background while the caller carries on with its business.
+These concurrent objects are called "actors". Actors are somewhere in between
+the kind of object you're typically used to working with and a network service.
+
+Usage
+-----
+
+To use Celluloid, define a normal Ruby class that includes Celluloid::Actor
+
+    class Sheen
+      include Celluloid::Actor
+  
+      def initialize(name)
+        @name = name
+      end
+  
+      def set_status(status)
+        @status = status
+      end
+      
+      def report
+        "#{@name} is #{@status}"
+      end
+    end
+    
+If you call Sheen.new, you'll wind up with a plain old Ruby object. To
+create a concurrent object instead of a regular one, use Sheen.spawn:
+
+    >> charlie = Sheen.spawn "Charlie Sheen"
+     => #<Celluloid::Actor(Sheen:0x00000100a312d0) @name="Charlie Sheen">
+    >> charlie.set_status "winning!"
+     => "winning!" 
+    >> charlie.report
+     => "Charlie Sheen is winning!" 
+    >> charlie.set_status! "asynchronously winning!"
+     => nil 
+    >> charlie.report
+     => "Charlie Sheen is asynchronously winning!" 
+
+Calling spawn creates a concurrent object running inside its own thread. You
+can call methods on this concurrent object just like you would any other Ruby
+object. The Sheen#set_status method works exactly like you'd expect, returning
+the last expression evaluated.
+
+However, Celluloid's secret sauce kicks in when you call banged predicate
+methods (i.e. methods ending in !). Even though the Sheen class has no 
+set_status! method, you can still call it. Why is this? Because bang methods
+have a special meaning in Celluloid. (Note: this also means you can't define
+bang methods on Celluloid classes and expect them to be callable from other
+objects)
+
+Adding a bang to the end of a method instructs Celluloid that you would like
+for the given method to be called _asynchronously_. This means that rather
+than the caller waiting for a response, the caller sends a message to the
+concurrent object that you'd like the given method invoked, and then the
+caller proceeds without waiting for a response. The concurrent object
+receiving the message will then process the method call in the background.
+
+Adding a bang to a method name is a convention in Ruby used to indicate that
+the method is in some way "dangerous", and in Celluloid this is no exception.
+You have no guarantees that just because you made an asynchronous call it was
+ever actually invoked. Asynchronous calls will never raise an exception, even
+if an exception occurs when the receiver is processing it. Worse, unhandled
+exceptions will crash the receiver, and making an asynchronous call to a
+crashed object will not raise an error.
+
+However, you can still handle errors created by asynchronous calls using
+two features of Celluloid called _supervisors_ and _linking_.
+
+Supervisors
+-----------
+
+You may be familiar with tools like Monit or God which keep an eye on your
+applications and restart them when they crash. Celluloid supervisors work in
+a similar fashion, except instead of monitoring applications, they monitor
+individual actors and restart them when they crash. Crashes occur whenever
+an unhandled exception is raised anywhere within an actor.
+
+To supervise an actor, start it with the _supervise_ method. Using the Sheen
+class from the example above:
+
+    >> supervisor = Sheen.supervise "Charlie Sheen"
+     => #<Celluloid::Supervisor(Sheen) "Charlie Sheen">
+ 
+This created a new Celluloid::Supervisor actor, and also created a new Sheen
+actor, giving its initialize method the argument "Charlie Sheen". The 
+_supervise_ method has the same method signature as _spawn_. However, rather
+than returning the newly created actor, _supervise_ returns the supervisor.
+To retrieve the actor that the supervisor is currently using, use the
+Celluloid::Supervisor#actor method:
+
+    >> supervisor = Sheen.supervise "Charlie Sheen"
+     => #<Celluloid::Supervisor(Sheen) "Charlie Sheen">
+    >> charlie = supervisor.actor
+     => #<Celluloid::Actor(Sheen:0x00000100a312d0)>
+     
+Supervisors can also automatically put actors into the actor _registry_ using
+the supervise_as method:
+
+    >> Sheen.supervise_as :charlie, "Charlie Sheen"
+     => #<Celluloid::Supervisor(Sheen) "Charlie Sheen">
+    >> charlie = Celluloid::Actor[:charlie]
+     => #<Celluloid::Actor(Sheen:0x00000100a312d0)>
+ 
+In this case, the supervisor will ensure that an actor of the Sheen class,
+created using the given arguments, is aways available by calling
+Celluloid::Actor[:charlie]. The first argument to supervise_as is the name
+you'd like the newly created actor to be registered under. The remaining
+arguments are passed to initialize just like you called _new_ or _spawn_.
+
+See the "Registry" section below for more information on the actor registry
+
+Linking
+-------
+
+Whenever any unhandled exceptions occur in any of the methods of an actor,
+that actor crashes and dies. Let's start with an example:
+
+    class JamesDean
+      include Celluloid::Actor
+      class CarInMyLaneError < StandardError; end
+      
+      def drive_little_bastard
+        raise CarInMyLaneError, "that guy's gotta stop. he'll see us"
+      end
+    end
+    
+Now, let's have James drive Little Bastard and see what happens:
+
+    >> james = JamesDean.spawn
+     => #<Celluloid::Actor(JamesDean:0x1068)> 
+    >> james.drive_little_bastard!
+     => nil 
+    >> james
+     => #<Celluloid::Actor(JamesDean:0x1068) dead> 
+    
+When we told james asynchronously to drive Little Bastard, it killed him! If
+we were Elizabeth Taylor, co-star in James' latest film at the time of his
+death, we'd certainly want to know when he died. So how can we do that?
+
+Actors can _link_ to other actors they're interested in and want to receive
+crash notifications from. In order to receive these events, we need to use the
+trap_exit method to be notified of them. Let's look at how a hypothetical
+Elizabeth Taylor object could be notified that James Dean has crashed:
+
+    class ElizabethTaylor
+      include Celluloid::Actor
+      trap_exit :actor_died
+  
+      def actor_died(actor, reason)
+        puts "Oh no! #{actor.inspect} has died because of a #{reason.class}"
+      end
+    end
+
+We've now used the trap_exit method to configure a callback which is invoked
+whenever any linked actors crashed. Now we need to link Elizabeth to James so
+James' crash notifications get sent to her:
+
+    >> james = JamesDean.spawn
+     => #<Celluloid::Actor(JamesDean:0x11b8)> 
+    >> elizabeth = ElizabethTaylor.spawn
+     => #<Celluloid::Actor(ElizabethTaylor:0x11f0)> 
+    >> elizabeth.link james
+     => #<Celluloid::Actor(JamesDean:0x11b8)> 
+    >> james.drive_little_bastard!
+     => nil 
+    Oh no! #<Celluloid::Actor(JamesDean:0x11b8) dead> has died because of a JamesDean::CarInMyLaneError
+
+Elizabeth called the _link_ method to receive crash events from James. Because
+Elizabeth was linked to James, when James crashed, James' exit message was
+sent to her. Because Elizabeth was trapping the exit messages she received
+using the trap_exit method, the callback she specified was invoked, allowing
+her to take action (in this case, printing the error). But what would happen
+if she weren't trapping exits? Let's break James apart into two separate
+objects, one for James himself and one for Little Bastard, his car:
+
+    class PorscheSpider
+      include Celluloid::Actor
+      class CarInMyLaneError < StandardError; end
+  
+      def drive_on_route_466
+        raise CarInMyLaneError, "head on collision :("
+      end
+    end
+    
+    class JamesDean
+      include Celluloid::Actor
+      
+      def initialize
+        @little_bastard = PorscheSpider.spawn_link
+      end
+      
+      def drive_little_bastard
+        @little_bastard.drive_on_route_466
+      end
+    end
+    
+If you take a look in JamesDean#initialize, you'll notice that to create an
+instance of PorcheSpider, James is calling the spawn_link method.
+
+This method works similarly to _spawn_, except it combines _spawn_ and _link_ 
+into a single call.
+
+Now what happens if we repeat the same scenario with Elizabeth Taylor watching
+for James Dean's crash?
+
+    >> james = JamesDean.spawn
+     => #<Celluloid::Actor(JamesDean:0x1108) @little_bastard=#<Celluloid::Actor(PorscheSpider:0x10ec)>> 
+    >> elizabeth = ElizabethTaylor.spawn
+     => #<Celluloid::Actor(ElizabethTaylor:0x1144)> 
+    >> elizabeth.link james
+     => #<Celluloid::Actor(JamesDean:0x1108) @little_bastard=#<Celluloid::Actor(PorscheSpider:0x10ec)>> 
+    >> james.drive_little_bastard!
+     => nil 
+    Oh no! #<Celluloid::Actor(JamesDean:0x1108) dead> has died because of a PorscheSpider::CarInMyLaneError
+
+When Little Bastard crashed, it killed James as well. Little Bastard killed 
+James, and because Elizabeth was trapping James' exit events, she received the 
+notification of James' death.
+
+Actors that are linked together propagate their error messages to all other 
+actors that they're linked to. Unless those actors are trapping exit events,
+those actors too will die, like James did in this case. If you have many, 
+many actors linked together in a large object graph, killing one will kill them
+all unless they are trapping exits.
+
+This allows you to factor your problem into several actors. If an error occurs
+in any of them, it will kill off all actors used in a particular system. In
+general, you'll probably want to have a supervisor start a single actor which
+is in charge of a particular part of your system, and have that actor 
+spawn_link to other actors which are part of the same system. If any error
+occurs in any of these actors, all of them will be killed off and the entire
+subsystem will be restarted by the supervisor in a clean state.
+
+If, for any reason, you've linked to an actor and want to sever the link,
+there's a corresponding _unlink_ method to remove links between actors.
+
+Registry
+--------
+
+Celluloid lets you register actors so you can refer to them symbolically.
+You can register Actors using Celluloid::Actor[]:
+
+    >> james = JamesDean.spawn
+     => #<Celluloid::Actor(JamesDean:0x80c27ce0)> 
+    >> Celluloid::Actor[:james] = james
+     => #<Celluloid::Actor(JamesDean:0x80c27ce0)> 
+    >> Celluloid::Actor[:james]
+     => #<Celluloid::Actor(JamesDean:0x80c27ce0)> 
+
+The Celluloid::Actor constant acts as a hash, allowing you to register actors
+under the name of your choosing, and access actors by name rather than
+reference. This is important because actors may crash. If you're attempting to
+reference an actor explicitly by storing it in a variable, you may be holding
+onto a reference to a crashed copy of that actor, rather than talking to a
+working, freshly-restarted version.
+
+The main use of the registry is for interfacing with actors that are
+automatically restarted by supervisors when they crash.
+ 
+Contributing to Celluloid
+-------------------------
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+Copyright
+---------
+
+Copyright (c) 2011 Tony Arcieri. See LICENSE.txt for further details.

data/Rakefile

@@ -0,0 +1,51 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name        = "celluloid"
+  gem.homepage    = "http://github.com/tarcieri/celluloid"
+  gem.license     = "MIT"
+  gem.summary     = "Ruby concurrency made easy! Or at least, easier..."
+  gem.description = "Celluloid is a concurrent object framework inspired by the Actor Model"
+  gem.email       = "tony@medioh.com"
+  gem.authors     = ["Tony Arcieri"]
+  
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  version = File.exist?('VERSION') ? File.read('VERSION') : ""
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "celluloid #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end

data/VERSION

@@ -0,0 +1 @@
+0.0.1

data/celluloid.gemspec

@@ -0,0 +1,87 @@
+# Generated by jeweler
+# DO NOT EDIT THIS FILE DIRECTLY
+# Instead, edit Jeweler::Tasks in Rakefile, and run 'rake gemspec'
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{celluloid}
+  s.version = "0.0.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Tony Arcieri"]
+  s.date = %q{2011-05-11}
+  s.description = %q{Celluloid is a concurrent object framework inspired by the Actor Model}
+  s.email = %q{tony@medioh.com}
+  s.extra_rdoc_files = [
+    "LICENSE.txt",
+    "README.md"
+  ]
+  s.files = [
+    ".autotest",
+    ".document",
+    ".rspec",
+    "Gemfile",
+    "Gemfile.lock",
+    "LICENSE.txt",
+    "README.md",
+    "Rakefile",
+    "VERSION",
+    "celluloid.gemspec",
+    "lib/celluloid.rb",
+    "lib/celluloid/actor.rb",
+    "lib/celluloid/actor_proxy.rb",
+    "lib/celluloid/calls.rb",
+    "lib/celluloid/core_ext.rb",
+    "lib/celluloid/events.rb",
+    "lib/celluloid/future.rb",
+    "lib/celluloid/linking.rb",
+    "lib/celluloid/mailbox.rb",
+    "lib/celluloid/registry.rb",
+    "lib/celluloid/responses.rb",
+    "lib/celluloid/supervisor.rb",
+    "lib/celluloid/waker.rb",
+    "spec/actor_spec.rb",
+    "spec/future_spec.rb",
+    "spec/mailbox_spec.rb",
+    "spec/registry_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/supervisor_spec.rb",
+    "spec/waker_spec.rb"
+  ]
+  s.homepage = %q{http://github.com/tarcieri/celluloid}
+  s.licenses = ["MIT"]
+  s.require_paths = ["lib"]
+  s.rubygems_version = %q{1.6.2}
+  s.summary = %q{Ruby concurrency made easy! Or at least, easier...}
+  s.test_files = [
+    "spec/actor_spec.rb",
+    "spec/future_spec.rb",
+    "spec/mailbox_spec.rb",
+    "spec/registry_spec.rb",
+    "spec/spec_helper.rb",
+    "spec/supervisor_spec.rb",
+    "spec/waker_spec.rb"
+  ]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<celluloid>, [">= 0"])
+      s.add_development_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_development_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_development_dependency(%q<jeweler>, ["~> 1.5.2"])
+    else
+      s.add_dependency(%q<celluloid>, [">= 0"])
+      s.add_dependency(%q<rspec>, [">= 2.3.0"])
+      s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+      s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+    end
+  else
+    s.add_dependency(%q<celluloid>, [">= 0"])
+    s.add_dependency(%q<rspec>, [">= 2.3.0"])
+    s.add_dependency(%q<bundler>, ["~> 1.0.0"])
+    s.add_dependency(%q<jeweler>, ["~> 1.5.2"])
+  end
+end
+