celluloid 0.18.0.pre2 → 0.18.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 901d303444b94a61e2b4faaf1e957ae442acd5ae2ae0864f9c0fd7af7dbfbe46
-  data.tar.gz: ff7fc82458f6b591a74fbc59d329db9082f195f466c9be7be12dec1c8073d621
+  metadata.gz: fede4c9c3907c29a0dc303e711077a7b3196fc2acaf3b099ee98b197076c3fdc
+  data.tar.gz: f8bd8ffc37cddd24000d66e56d1bafc03796e309101fa4b6f5e02ab5e11f9aac
 SHA512:
-  metadata.gz: 71f12fd99271e598bf0e125b1ce44f5b1bc420b34dfabdabb64e80f38e8736c54a5295f6d9ecfcfbdcfde78a10bc79388dba4a18a0b7873415ed86050cc76420
-  data.tar.gz: 834996dba23ffde88d9970cd86bb0e5b6975f7658867d3f0f1d2eaba88ab1ebf0b45cc5847a63b11af0df390cab680be94aeb25d0bb5c791f6e997bd172dadf6
+  metadata.gz: dc813a35e9f74a49a0f875d290e41fe6445dfd7f6778b46bd3e19b741446c590e1b05be2bc697e6d8641548165baee2494a49960fa7e3782f71b50a13cb50ee1
+  data.tar.gz: 9a47f043d4929f833b05187c88a487351e4f26da10038b1045497ed3c7e0fdf980e4b5fe753d7cc4ae1f2db70d0d5fe5966520e2bdff5f08a558c62d82c12fee

data/CHANGES.md

@@ -1,6 +1,150 @@
-## 0.18.0.pre2 (Final release TBD)
+## 0.18.0 (2020-12-05)
 
-* TODO (before 0.18.0 final): release notes
+[0.18.0]: https://github.com/celluloid/celluloid/compare/v0.17.3...v0.18.0
+
+* [#804](https://github.com/celluloid/celluloid/pull/804)
+  Remove deprecation warnings
+
+* [#802](https://github.com/celluloid/celluloid/pull/802)
+  Remove lattice link itself.
+
+* [#797](https://github.com/celluloid/celluloid/pull/797)
+  Update Ruby versions in CI script
+
+* [#801](https://github.com/celluloid/celluloid/pull/801)
+  Associate Open Collective sponsorship option
+
+* [#800](https://github.com/celluloid/celluloid/pull/800)
+  Streamline README
+
+* [#799](https://github.com/celluloid/celluloid/pull/799)
+  Update links, add diagram preview.
+
+* [#796](https://github.com/celluloid/celluloid/pull/796)
+  Create Class Diagram in Draw.io
+
+* [#798](https://github.com/celluloid/celluloid/pull/798)
+  Pertinent Newsflash
+
+* [#792](https://github.com/celluloid/celluloid/pull/792)
+  CI: 2.5.5, 2.6.2
+
+* [#788](https://github.com/celluloid/celluloid/pull/788)
+  Travis: Include Ruby 2.5, 2.6
+
+* [#787](https://github.com/celluloid/celluloid/pull/787)
+  Travis config: drop old configuration sudo: false
+
+* [#786](https://github.com/celluloid/celluloid/pull/786)
+  Travis: use jruby-9.2.5.0
+
+* [#783](https://github.com/celluloid/celluloid/pull/783)
+  v0.18.0.pre2
+
+* [#782](https://github.com/celluloid/celluloid/pull/782)
+  Merge 'celluloid-supervision' back into the tree
+
+* [#781](https://github.com/celluloid/celluloid/pull/781)
+  .gitmodules: No longer used
+
+* [#780](https://github.com/celluloid/celluloid/pull/780)
+  README.md: Link to unmaintained issue
+
+* [#778](https://github.com/celluloid/celluloid/pull/778)
+  README.md: Add "maintained: no! (as of 2016)" badge
+
+* [#777](https://github.com/celluloid/celluloid/pull/777)
+  gemspec: Metadata with supported links
+
+* [#776](https://github.com/celluloid/celluloid/pull/776)
+  Travis: use jruby-9.2.0.0
+
+* [#775](https://github.com/celluloid/celluloid/pull/775)
+  Travis: jruby-9.1.17.0
+
+* [#769](https://github.com/celluloid/celluloid/pull/769)
+  Travis: jruby-9.1.15.0
+
+* [#768](https://github.com/celluloid/celluloid/pull/768)
+  Travis: use latest JRuby
+
+* [#767](https://github.com/celluloid/celluloid/pull/767)
+  CHANGES: Add GitHub compare link on each heading
+
+* [#766](https://github.com/celluloid/celluloid/pull/766)
+  Fix celluloid/celluloid#758
+
+* [#765](https://github.com/celluloid/celluloid/pull/765)
+  Travis: jruby-9.1.13.0
+
+* [#761](https://github.com/celluloid/celluloid/pull/761)
+  Travis: jruby-9.1.12.0
+
+* [#760](https://github.com/celluloid/celluloid/pull/760)
+  Travis: jruby-9.1.10.0
+
+* [#759](https://github.com/celluloid/celluloid/pull/759)
+  Travis: jruby-9.1.9.0
+
+* [#757](https://github.com/celluloid/celluloid/pull/757)
+  parameterize error message so old and new Rubies match text
+
+* [#756](https://github.com/celluloid/celluloid/pull/756)
+  Travis: latest stable rubies
+
+* [#754](https://github.com/celluloid/celluloid/pull/754)
+  README: Fix badge rendering in Markdown
+
+* [#753](https://github.com/celluloid/celluloid/pull/753)
+  Travis: use jruby-9.1.8.0
+
+* [#752](https://github.com/celluloid/celluloid/pull/752)
+  Misspellings
+
+* [#749](https://github.com/celluloid/celluloid/pull/749)
+  Return false from Celluloid.running? if Celluloid.boot hasn't been called
+
+* [#751](https://github.com/celluloid/celluloid/pull/751)
+  Travis: Use JRuby 9.1.7.0
+
+* [#740](https://github.com/celluloid/celluloid/pull/740)
+  Global variables: stop the bleeding
+
+* [#739](https://github.com/celluloid/celluloid/pull/739)
+  Remove hacks around old MRIs, JRuby, and rbx
+
+* [#738](https://github.com/celluloid/celluloid/pull/738)
+  Update to RuboCop 0.45.0 (with new rubocop.yml policy)
+
+* [#737](https://github.com/celluloid/celluloid/pull/737)
+  Simplify dependencies: merge 'essentials' and 'culture' repos
+
+* [#736](https://github.com/celluloid/celluloid/pull/736)
+  Remove $CELLULOID_BACKPORTED and $CELLULOID_MANAGED
+
+* [#735](https://github.com/celluloid/celluloid/pull/735)
+  Require Ruby 2.2.6+
+
+* [#729](https://github.com/celluloid/celluloid/pull/729)
+  Remove mysterious Fiber.yield
+
+* [#721](https://github.com/celluloid/celluloid/pull/721)
+  Instruction for cloning Celluloid via github
+
+* [#715](https://github.com/celluloid/celluloid/pull/715)
+  fix error response reference in Future#cancel
+
+* [#712](https://github.com/celluloid/celluloid/pull/712)
+  Add RBX-3 to the build
+
+* [#711](https://github.com/celluloid/celluloid/pull/711)
+  Added bundler cache
+
+* [#709](https://github.com/celluloid/celluloid/pull/709)
+  Fix autostart. Fixes https://github.com/celluloid/celluloid/issues/698
+
+* [#705](https://github.com/celluloid/celluloid/pull/705)
+  Adding method source code path to backtrace
 
 ## [0.17.3] (2016-01-18)
 

data/README.md

@@ -4,6 +4,7 @@
 [![MIT licensed][license-image]][license-link]
 [![Build Status][build-image]][build-link]
 [![Maintained: no][maintained-image]][maintained-link]
+[![Gitter Chat][gitter-image]][gitter-link]
 
 [celluloid-logo-image-raw]: https://raw.github.com/celluloid/celluloid-logos/master/celluloid/celluloid.png
 [gem-image]: https://badge.fury.io/rb/celluloid.svg
@@ -14,92 +15,29 @@
 [license-link]: https://github.com/celluloid/celluloid/blob/master/LICENSE.txt
 [maintained-image]: https://img.shields.io/maintenance/no/2016.svg
 [maintained-link]: https://github.com/celluloid/celluloid/issues/779
+[gitter-image]: https://badges.gitter.im/badge.svg
+[gitter-link]: https://gitter.im/celluloid/celluloid
 
-_NOTE: This is the 0.18.x **development** branch of Celluloid. For the 0.17.x
-**stable** branch, please see:_
-
-https://github.com/celluloid/celluloid/tree/0-17-stable
-
-> "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 provides a simple and natural way to build fault-tolerant concurrent
-programs in Ruby. With Celluloid, you can build systems out of concurrent
-objects just as easily as you build sequential programs out of regular objects.
-Recommended for any developer, including novices, Celluloid should help ease
-your worries about building multithreaded Ruby programs.
-
-## Motivation
-
-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", 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
-together into a single concurrent object oriented programming model,
-encapsulating state in concurrent objects and thus avoiding many of the
-problems associated with multithreaded programming. Celluloid provides many
-features which make concurrent programming simple, easy, and fun:
-
-* __Automatic "deadlock-free" synchronization:__ Celluloid uses a concurrent
-  object model which combines method dispatch and thread synchronization.
-  Each actor is a concurrent object running in its own thread, and every method
-  invocation is wrapped in a fiber that can be suspended whenever it calls
-  out to other actors, and resumed when the response is available. This means
-  methods which are waiting for responses from other actors, external messages,
-  or other system events (including I/O with Celluloid::IO) can be suspended
-  and will never block other methods that are ready to run. This won't prevent
-  bugs in Celluloid, bugs in other thread-safe libraries you use, and even
-  certain "dangerous" features of Celluloid from causing your program to
-  deadlock, but in general, programs built with Celluloid will be naturally
-  immune to deadlocks.
-
-* __Fault-tolerance:__ Celluloid has taken to heart many of Erlang's ideas
-  about fault-tolerance in order to enable self-healing applications.
-  The central idea: have you tried turning it off and on again? Celluloid
-  takes care of rebooting subcomponents of your application when they crash,
-  whether it's a single actor, or large (potentially multi-tiered) groups of
-  actors that are all interdependent. This means rather than worrying about
-  rescuing every last exception, you can just sit back, relax, and let parts
-  of your program crash, knowing Celluloid will automatically reboot them in
-  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 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
-  value it returns later? Celluloid futures do just that. It's like
-  calling ahead to a restaurant to place an order, so they can work
-  on preparing your food while you're on your way to pick it up.
-  When you ask for a method's return value, it's returned immediately
-  if the method has already completed, or otherwise the current method is
-  suspended until the value becomes available.
-
-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 instead of callback/deferrable soup)
-is available through the [Celluloid::IO](https://github.com/celluloid/celluloid-io)
-library.
-
-### Is it any good?
-
-[Yes](http://news.ycombinator.com/item?id=3067434)
-
-### Is It "Production Ready™"?
-
-Yes, many users are now running Celluloid in production.
-
-* **See:** [Projects Using Celluloid](https://github.com/celluloid/celluloid/wiki/Projects-Using-Celluloid)
+Celluloid is a framework for building asynchronous and multithreaded Ruby
+programs using object-oriented concepts.
+
+## Revival Process Underway
+
+`Celluloid` is in the process of being refactored and released back into the wild during `Google Summer of Code`. The next era will not have one individual active maintainer, but a team of collaborators. Going forward, previously dormant maintainer [Donovan Keme](https://github.com/digitalextremist) is returning to support future primary maintainer [Emese Padányi](https://github.com/emesepadanyi) during `GSoC 2020`. Her plan extends past the Summer program, and aims to revive the community and codebase of `Celluloid` together. Backing this process are [Harsh Deep](https://github.com/harsh183) and `GSoC` alumni [Dilum Navanjana](https://github.com/dilumn). We welcome your collaboration and contributions in this massive work.
+
+The codebase is being refactored to pursue a stable release with no deprecation warnings, and with this cleaned up:
+
+# ![Diagram][celluloid-diagram]
+*Diagram meticulously developed by [Emese Padányi](https://github.com/emesepadanyi)*
+
+[celluloid-diagram]: https://raw.githubusercontent.com/celluloid/celluloid/master/documentation/ClassDiagram-class_diagram.png
+
+### Proudly supported by the best cloud infrastructure provider in the world: [`DigitalOcean`](https://digitalocean.com)
 
 ## Discussion
 
-Like Celluloid? [Join the mailing list/Google Group](http://groups.google.com/group/celluloid-ruby)
-or visit us on IRC at #celluloid on freenode
+- [Gitter Chat][gitter-link]
+- [Google Group](https://groups.google.com/group/celluloid-ruby)
 
 ## Documentation
 
@@ -115,8 +53,7 @@ The following API documentation is also available:
 
 ## Related Projects
 
-Celluloid is the parent project of a related ecosystem of other projects. If you
-like Celluloid we definitely recommend you check them out:
+See also: [Projects Using Celluloid](https://github.com/celluloid/celluloid/wiki/Projects-Using-Celluloid)
 
 * [Reel][reel]: An "evented" web server based on `Celluloid::IO`
 * [DCell][dcell]: The Celluloid actor protocol distributed over 0MQ
@@ -125,80 +62,28 @@ like Celluloid we definitely recommend you check them out:
 * [Celluloid::ZMQ][celluloid-zmq]: "Evented" 0MQ support for `Celluloid` actors
 * [Celluloid::DNS][celluloid-dns]: An "evented" DNS server based on `Celluloid::IO`
 * [Celluloid::SMTP][celluloid-smtp]: An "evented" SMTP server based on `Celluloid::IO`
-* [Lattice][lattice]: A concurrent realtime web framework based on `Celluloid::IO`
 * [nio4r][nio4r]: "New IO for Ruby": high performance IO selectors
 * [Timers][timers]: A generic Ruby timer library for event-based systems
 
 [reel]: https://github.com/celluloid/reel/
 [dcell]: https://github.com/celluloid/dcell/
-[ecell]: https://github.com/celluloid/ecell/
+[ecell]: https://github.com/abstractive/ecell/
 [celluloid-io]: https://github.com/celluloid/celluloid-io/
 [celluloid-zmq]: https://github.com/celluloid/celluloid-zmq/
 [celluloid-dns]: https://github.com/celluloid/celluloid-dns/
-[celluloid-smtp]: https://github.com/celluloid/celluloid-smtp/
-[lattice]: https://github.com/celluloid/lattice/
+[celluloid-smtp]: https://github.com/abstractive/celluloid-smtp/
 [nio4r]: https://github.com/celluloid/nio4r/
 [timers]: https://github.com/celluloid/timers/
 
-## Installation
-
-Add this line to your application's Gemfile:
-
-    gem 'celluloid'
-
-And then execute:
-
-    $ bundle
-
-Or install it yourself as:
-
-    $ gem install celluloid
-
-Require Celluloid with:
-
-    require 'celluloid'
-
-## Supported Platforms
-
-This library aims to support and is [tested against][travis] the following Ruby
-versions:
-
-* Ruby 2.2.6+
-* Ruby 2.3.0+
-* JRuby 9.1.6.0+
-
-If something doesn't work on one of these versions, it's a bug.
-
-This library may inadvertently work (or seem to work) on other Ruby versions,
-however support will only be provided for the versions listed above.
-
-If you would like this library to support another Ruby version or
-implementation, you may volunteer to be a maintainer. Being a maintainer
-entails making sure all tests run and pass on that implementation. When
-something breaks on your implementation, you will be responsible for providing
-patches in a timely fashion. If critical issues for a particular implementation
-exist at the time of a major release, support for that Ruby version may be
-dropped.
-
-[travis]: http://travis-ci.org/celluloid/celluloid/
-
-## Additional Reading
-
-* [Concurrent Object-Oriented Programming in Python with ATOM][ATOM]
-  a similar system to Celluloid written in Python
-
-[ATOM]: http://citeseerx.ist.psu.edu/viewdoc/download;jsessionid=11A3EACE78AAFF6D6D62A64118AFCA7C?doi=10.1.1.47.5074&rep=rep1&type=pdf
-
 ## Contributing to Celluloid
 
-* Fork this repository on github
-* Make your changes and send us a pull request
-* If we like them we'll merge them
-* If we've accepted a patch, feel free to ask for commit access
+- Fork this repository on github
+- Make your changes and send us a pull request
+- Pull requests will be reviewed for inclusion in the project
 
 ## License
 
-Copyright (c) 2011-2016 Tony Arcieri, Donovan Keme.
+Copyright (c) 2011-2018 Tony Arcieri, Donovan Keme.
 
 Distributed under the MIT License. See [LICENSE.txt](https://github.com/celluloid/celluloid/blob/master/LICENSE.txt)
 for further details.

data/REFACTOR.md

@@ -0,0 +1 @@
+20200703113000: `require "celluloid/current"` is removed. use `require "celluloid"`

data/examples/configurations.rb

@@ -1,4 +1,4 @@
-require "celluloid/current"
+require "celluloid"
 
 puts "Use Supervision::Configuration objects!"
 

data/examples/timers.rb

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 
 $LOAD_PATH.push File.expand_path("../lib", __dir__)
-require "celluloid/current"
+require "celluloid"
 
 class TimerExample
   include Celluloid

data/lib/celluloid/version.rb

@@ -1,3 +1,3 @@
 module Celluloid
-  VERSION = "0.18.0.pre2".freeze
+  VERSION = "0.18.0".freeze
 end

metadata

@@ -1,15 +1,15 @@
 --- !ruby/object:Gem::Specification
 name: celluloid
 version: !ruby/object:Gem::Version
-  version: 0.18.0.pre2
+  version: 0.18.0
 platform: ruby
 authors:
 - Tony Arcieri
 - Donovan Keme
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-08-28 00:00:00.000000000 Z
+date: 2020-12-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: timers
@@ -39,6 +39,7 @@ files:
 - CONTRIBUTING.md
 - LICENSE.txt
 - README.md
+- REFACTOR.md
 - architecture.md
 - examples/basic_usage.rb
 - examples/configurations.rb
@@ -52,7 +53,6 @@ files:
 - lib/celluloid/actor.rb
 - lib/celluloid/actor/system.rb
 - lib/celluloid/autostart.rb
-- lib/celluloid/backported.rb
 - lib/celluloid/call/async.rb
 - lib/celluloid/call/block.rb
 - lib/celluloid/call/sync.rb
@@ -60,7 +60,6 @@ files:
 - lib/celluloid/cell.rb
 - lib/celluloid/condition.rb
 - lib/celluloid/core_ext.rb
-- lib/celluloid/current.rb
 - lib/celluloid/debug.rb
 - lib/celluloid/exceptions.rb
 - lib/celluloid/future.rb
@@ -93,7 +92,6 @@ files:
 - lib/celluloid/logging/ring_buffer.rb
 - lib/celluloid/mailbox.rb
 - lib/celluloid/mailbox/evented.rb
-- lib/celluloid/managed.rb
 - lib/celluloid/notifications.rb
 - lib/celluloid/pool.rb
 - lib/celluloid/probe.rb
@@ -118,10 +116,6 @@ files:
 - lib/celluloid/supervision/container/injections.rb
 - lib/celluloid/supervision/container/instance.rb
 - lib/celluloid/supervision/container/pool.rb
-- lib/celluloid/supervision/container/tree.rb
-- lib/celluloid/supervision/deprecate.rb
-- lib/celluloid/supervision/deprecate/supervise.rb
-- lib/celluloid/supervision/deprecate/validation.rb
 - lib/celluloid/supervision/service.rb
 - lib/celluloid/supervision/supervise.rb
 - lib/celluloid/supervision/validation.rb
@@ -201,7 +195,7 @@ metadata:
   mailing_list_uri: http://groups.google.com/group/celluloid-ruby
   source_code_uri: https://github.com/celluloid/celluloid
   wiki_uri: https://github.com/celluloid/celluloid/wiki
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -216,9 +210,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 2.0.0
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.4
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Actor-based concurrent object framework for Ruby
 test_files: []

data/lib/celluloid/backported.rb

@@ -1,6 +0,0 @@
-raise NotImplementedError, <<-MSG.strip.gsub(/\s+/, " ")
-  Celluloid 0.18 no-longer supports the "backported" API.
-  Please switch to using: `require 'celluloid'`
-  For more information, see:
-  https://github.com/celluloid/celluloid/wiki/0.18-API-changes
-MSG

data/lib/celluloid/current.rb

@@ -1,4 +0,0 @@
-# Legacy support for the prescribed 0.17 API
-# TODO: remove this in a future release
-
-require "celluloid"

data/lib/celluloid/managed.rb

@@ -1,6 +0,0 @@
-raise NotImplementedError, <<-MSG.strip.gsub(/\s+/, " ")
-  Celluloid 0.18 no-longer supports the "managed" API.
-  Please switch to using: `require 'celluloid'`
-  For more information, see:
-  https://github.com/celluloid/celluloid/wiki/0.18-API-changes
-MSG

data/lib/celluloid/supervision/deprecate.rb

@@ -1,9 +0,0 @@
-# TODO: Remove at 0.19.0
-module Celluloid
-  SupervisionGroup = Supervision::Container
-  Supervision::Group = Supervision::Container
-  Supervision::Member = Supervision::Container::Instance
-end
-
-require "celluloid/supervision/deprecate/supervise"
-require "celluloid/supervision/deprecate/validation"

data/lib/celluloid/supervision/deprecate/supervise.rb

@@ -1,105 +0,0 @@
-# TODO: Remove at 0.19.0
-module Celluloid
-  class << self
-    undef supervise rescue nil
-    def supervise(*args, &block)
-      supervisor = Supervision.router(*args)
-      supervisor.supervise(*args, &block)
-    end
-    undef supervise_as rescue nil
-    def supervise_as(name, *args, &block)
-      supervisor = Supervision.router(*args)
-      supervisor.supervise_as(name, *args, &block)
-    end
-  end
-  module ClassMethods
-    undef supervise rescue nil
-    def supervise(*args, &block)
-      args.unshift(self)
-      Celluloid.supervise(*args, &block)
-    end
-    undef supervise_as rescue nil
-    def supervise_as(name, *args, &block)
-      args.unshift(self)
-      Celluloid.supervise_as(name, *args, &block)
-    end
-  end
-
-  # Supervisors are actors that watch over other actors and restart them if
-  # they crash
-  class Supervisor
-    class << self
-      # Define the root of the supervision tree
-      attr_accessor :root
-
-      undef supervise rescue nil
-      def supervise(klass, *args, &block)
-        args.unshift(klass)
-        Celluloid.supervise(*args, &block)
-      end
-
-      undef supervise_as rescue nil
-      def supervise_as(name, klass, *args, &block)
-        args.unshift(klass)
-        Celluloid.supervise_as(name, *args, &block)
-      end
-    end
-  end
-
-  module Supervision
-    class << self
-      undef router rescue nil
-      def router(*_args)
-        # TODO: Actually route, based on :branch, if present; or else:
-        Celluloid.services
-      end
-    end
-    class Container
-      class << self
-        undef run! rescue nil
-        def run!(*args)
-          container = new(*args) do |g|
-            blocks.each do |block|
-              block.call(g)
-            end
-          end
-          container
-        end
-
-        undef run rescue nil
-        def run(*args)
-          loop do
-            supervisor = run!(*args)
-            # Take five, toplevel supervisor
-            sleep 5 while supervisor.alive? # Why 5?
-            Internals::Logger.error "!!! Celluloid::Supervision::Container #{self} crashed. Restarting..."
-          end
-        end
-
-        undef supervise rescue nil
-        def supervise(*args, &block)
-          blocks << lambda do |container|
-            container.supervise(*args, &block)
-          end
-        end
-
-        undef supervise_as rescue nil
-        def supervise_as(name, *args, &block)
-          blocks << lambda do |container|
-            container.supervise_as(name, *args, &block)
-          end
-        end
-      end
-
-      undef supervise rescue nil
-      def supervise(*args, &block)
-        add(Configuration.options(args, block: block))
-      end
-
-      undef supervise_as rescue nil
-      def supervise_as(name, *args, &block)
-        add(Configuration.options(args, block: block, as: name))
-      end
-    end
-  end
-end

data/lib/celluloid/supervision/deprecate/validation.rb

@@ -1,54 +0,0 @@
-module Celluloid
-  module Supervision
-    class Configuration
-      class << self
-        # argument scenarios:
-        #   * only class ( becomes :type )
-        #   * class ( becomes :type ), hash*
-        #   * hash ( *with :type, and perhaps :as, :size, :args, :block, :registry )
-        #          ( any keys expected are pulled out: may want to check on arity? )
-        #          ( the pulling out of keys is where danger mentioned above comes )
-        undef parse rescue nil
-        def parse(args)
-          return args if args.is_a? Configuration::Instance
-          options = { args: [] }
-          return { type: args } if args.is_a? Class
-          if args.is_a? Hash
-            return args
-          elsif args.is_a? Array
-            if args.length == 1
-              return args[0] if args.first.is_a? Configuration::Instance
-              return { type: args.first } if args.first.is_a? Class
-              if args.first.is_a?(Hash) && args = args.pop
-                return args
-              end
-              options[:args] = args if args.any?
-            elsif args.length > 1
-              # TODO: don't use each
-              options.merge! args.pop if args.last.is_a? Hash
-              options[:type] = args.shift if args.first.is_a? Class
-              options[:args] += args if args.any?
-            end
-          end
-          options
-        end
-
-        # This is dangerous. It is temporary, until `Supervision::Configuration` is entrenched.
-        # Since :type, :as, etc are used by the supervision group/member to initialize,
-        # those will not appear in the resulting actor's initialize call.
-        undef options rescue nil
-        def options(args, options = {})
-          return args.merge!(options) if args.is_a? Configuration::Instance
-          # Not a Supervision:Configuration?
-          # Try to guess its structure and build one:
-          options = parse(args).merge(options)
-          options[:configuration] = Container::Behavior.configure(options)
-          options[:args].compact! if options[:args].is_a? Array
-          options.reject! { |_k, v| v.nil? }
-          Configuration.valid? options, true
-          options
-        end
-      end
-    end
-  end
-end