container.rb in celluloid-supervision-0.20.0.pre5

- old
+ new

@@ -16,12 +16,12 @@
         end
 
         def top(options)
           {
             as: (options.delete(:as)),
-            branch: (options.delete(:branch) || :services),
             type: (options.delete(:type) || self),
+            branch: (options.delete(:branch) || :services),
             supervise: options.delete(:supervise) || [],
           }
         end
 
         # Actors or sub-applications to be supervised
@@ -38,54 +38,39 @@
           end
           container
         end
 
         # Run the application in the foreground with a simple watchdog
-        def run(_options)
+        def run(options={})
           loop do
-            supervisor = run!(options = {})
+            supervisor = run!(options)
 
             # Take five, toplevel supervisor
             sleep 5 while supervisor.alive? # Why 5?
 
             Internals::Logger.error "!!! Celluloid::Supervision::Container #{self} crashed. Restarting..."
           end
         end
-
-        # Register one or more actors to be launched and supervised
-        def supervise(config, &block)
-          blocks << lambda do |container|
-            container.add(Configuration.options(config, block: block))
-          end
-        end
       end
 
-      def supervise(config, &block)
-        add(Configuration.options(config, block: block))
-      end
-
       finalizer :finalize
 
       attr_accessor :registry
 
       # Start the container.
       def initialize(options={})
-        options ||= {}
         options = {registry: options} if options.is_a? Internals::Registry
         @state = :initializing
         @actors = [] # instances in the container
         @registry = options.delete(:registry) || Celluloid.actor_system.registry
         @branch = options.delete(:branch) || :services
         yield current_actor if block_given?
       end
 
-      execute_block_on_receiver :initialize, :supervise # DEPRECIATED: , :supervise_as
+      execute_block_on_receiver :initialize, :supervise, :supervise_as
 
       def add(configuration)
-        unless configuration.is_a? Configuration::Instance
-          configuration = Configuration.options(configuration)
-        end
-        Configuration.valid? configuration, true
+        Configuration.valid?(configuration, true)
         @actors << Instance.new(configuration.merge(registry: @registry, branch: @branch))
         @state = :running
         add_accessors configuration
         Actor.current
       end