autorespawn 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ea386cb98108e534b9f65033e7f664ec13321893
-  data.tar.gz: 7a8e260d15d67f91563da5505f6c42878548301e
+  metadata.gz: f350f615e8e53d1e5c4ffa35cf876dba59b3f894
+  data.tar.gz: 85ae94deab4d55b202d7ab3595a58e9e4595ddf0
 SHA512:
-  metadata.gz: 56804a4ae5f3410c656a0e95d35c1504a215c2bdee3769f65b51496df699c4c4238c1c2dba2490a5c5bca524f7b4ed752f4a32b14f70758c2184bf37f18bb7d2
-  data.tar.gz: 7d2735d95211f6e70b4ad28ca5204e292bd2775dfdebdff8961332d6b5b84c4d37680d63af48a657fb617f11bb206d967201a70b287888b5182b6ce7946fcba1
+  metadata.gz: 64fb8e03ca65dcd7e2989c137a8c21ba74eb7dc946871f6c58c633f95fa11038bf96f62193be29d6e7373d2aeb7201207a3d81d829b341341bbd0d1dfc1d7f2c
+  data.tar.gz: 664506705104437abfb05e9f48b2ba4c725548322134078a5bdfac705d291705e7141886865476f8db64fcc7f4506e25a050f5810cfd5f5c725d303281181f09

data/.travis.yml

@@ -1,4 +1,5 @@
 language: ruby
 rvm:
-  - 2.1.2
+  - 2.1.6
+  - 2.2.2
 before_install: gem install bundler -v 1.10.5

data/README.md

@@ -1,15 +1,20 @@
 # Autorespawn
 
+[![Build Status](https://travis-ci.org/doudou/autorespawn.svg?branch=master)](https://travis-ci.org/doudou/autorespawn)
+[![Gem Version](https://badge.fury.io/rb/autorespawn.svg)](http://badge.fury.io/rb/autorespawn)
+[![Coverage Status](https://coveralls.io/repos/doudou/autorespawn/badge.svg?branch=master&service=github)](https://coveralls.io/github/doudou/autorespawn?branch=master)
+[![Documentation](http://b.repl.ca/v1/yard-docs-blue.png)](http://rubydoc.info/gems/autorespawn/frames)
+
 Autorespawn is an implementation of the popular autoreload scheme, which reloads
 Ruby program files when they change, but instead execs/spawns the underlying
 program again. This avoids common issues related to the load mechanism.
 
-## Usage
+## Standalone Usage
 
 Require all the files you need autorespawn to watch and then do
 
 ~~~
-Autorespawn.autorespawn do
+Autorespawn.run do
    # Add the program's functionality here
 end
 ~~~
@@ -18,10 +23,45 @@ If you touch ARGV and $0, you will want to pass the program and arguments
 explicitely
 
 ~~~
-Autorespawn.autorespawn 'program', 'argument0', 'argument1' do
+Autorespawn.run 'program', 'argument0', 'argument1' do
+end
+~~~
+
+## Master/slave mode
+
+The main usage I designed this gem for was to implement an autotest scheme that
+does not use #load, and that does restart tests whose dependencies are changed
+(autotest only looks for the test files). That means a few 100 subcommands that
+need to be spawned and managed. Not really feasible without some kind of manager
+behind the scene.
+
+Autorespawn can be started used in master/slave mode. Some processes would be
+spawning new subcommands by registering them with the `Autorespawn#add_slave` method, while
+other are workers. In my autotest prototype, the same script is called in both
+cases, only the codepaths are different:
+
+~~~ ruby
+manager = Autorespawn.new
+if build_axis.empty? == 1
+    manager.run do
+        # Perform the work
+    end
+else
+    build_axis.each do |cmdline|
+        manager.add_slave(*cmdline)
+    end
+    manager.run
 end
 ~~~
 
+It is safe to use this scheme recursively. Slaves who call `#add_slave` will
+simply pass the request to the master.
+
+## TODO
+
+Manage the dependency between slaves that called `add_slave` and these slaves,
+i.e. auto-remove the level 2 slaves when the level 1 changes and is respawned.
+
 ## Installation
 
 Add this line to your application's Gemfile:

data/autorespawn.gemspec

@@ -9,6 +9,8 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Sylvain Joyeux"]
   spec.email         = ["sylvain.joyeux@m4x.org"]
 
+  spec.required_ruby_version = ">= 2.1.0"
+
   spec.summary       = "functionality to respawn a Ruby program when its source changes"
   spec.description   =<<-EOD
 This gem implements the functionality to take a signature of the current Ruby
@@ -28,4 +30,5 @@ EOD
   spec.add_development_dependency "minitest", ">= 5.0", "~> 5.0"
   spec.add_development_dependency "fakefs", ">= 0.6", "~> 0.6.0"
   spec.add_development_dependency 'flexmock', ">= 2.0", '~> 2.0'
+  spec.add_development_dependency "coveralls"
 end

data/lib/autorespawn.rb

@@ -1,8 +1,281 @@
+require 'set'
 require "autorespawn/version"
 require "autorespawn/exceptions"
 require "autorespawn/program_id"
 require "autorespawn/watch"
+require "autorespawn/slave"
+require "autorespawn/manager"
 
-module Autorespawn
-    # Your code goes here...
+# Automatically exec's the current program when one of the source file changes
+#
+# The exec is done at very-well defined points to avoid weird state, and it is
+# possible to define cleanup handlers beyond Ruby's at_exit mechanism
+#
+# Call this method from the entry point of your program, giving it the actual
+# program functionality as a block. The method will exec and spawn subprocesses
+# at will, when needed, and call the block in these subprocesses as required.
+#
+# At the point of call, all of the program's dependencies must be
+# already required, as it is on this basis that the auto-reloading will
+# be done
+#
+# This method does NOT return
+#
+# @param [Array<String>] command the command to be executed. It is
+#   passed as-is to Kernel.spawn and Kernel.exec
+# @param options keyword options to pass to Kernel.spawn and Kernel.exec
+class Autorespawn
+    INITIAL_STATE_FD = "AUTORESPAWN_AUTORELOAD"
+
+    SLAVE_RESULT_ENV = 'AUTORESPAWN_SLAVE_RESULT_FD'
+    SLAVE_INITIAL_STATE_ENV = 'AUTORESPAWN_SLAVE_INITIAL_STATE_FD'
+
+    def self.slave_result_fd
+        @slave_result_fd
+    end
+    def self.slave_initial_state_fd
+        @slave_initial_state_fd
+    end
+    def self.slave?
+        !!slave_result_fd
+    end
+
+    # Delete the envvars first, we really don't want them to leak
+    slave_initial_state_fd = ENV.delete(SLAVE_INITIAL_STATE_ENV)
+    slave_result_fd = ENV.delete(SLAVE_RESULT_ENV)
+
+    if slave_initial_state_fd
+        @slave_initial_state_fd = Integer(slave_initial_state_fd)
+    end
+    if slave_result_fd
+        @slave_result_fd = Integer(slave_result_fd)
+    end
+
+    # The arguments that should be passed to Kernel.exec in standalone mode
+    #
+    # Ignored in slave mode
+    #
+    # @return [(Array,Hash)]
+    attr_reader :process_command_line
+
+    # Set of callbacks called just before we respawn the process
+    #
+    # @return [Array<#call>]
+    attr_reader :respawn_handlers
+
+    # @return [ProgramID] object currently known state of files makind this
+    #   program
+    attr_reader :program_id
+
+    # @return [Array<Exception>] exceptions received in a {#requires} block or
+    #   in a file required with {#require}
+    attr_reader :exceptions
+
+    # Set of paths that have been required within a {#requires} block or through
+    # {#require}
+    #
+    # @return [Set<Pathname>]
+    attr_reader :required_paths
+
+    # Set of paths that are part of an error backtrace
+    #
+    # This is updated in {#requires} or {#require}
+    #
+    # @return [Set<Pathname>]
+    attr_reader :error_paths
+
+    # In master/slave mode, the list of subcommands that the master should spawn
+    attr_reader :subcommands
+
+    def initialize(*command, track_current: false, **options)
+        if command.empty?
+            command = [$0, *ARGV]
+        end
+        @process_command_line = [command, options]
+        @respawn_handlers = Array.new
+        @program_id = ProgramID.new
+        @exceptions = Array.new
+        @required_paths = Set.new
+        @error_paths = Set.new
+        @subcommands = Array.new
+        @exit_code = 0
+        if track_current
+            @required_paths = currently_loaded_files.to_set
+        end
+    end
+
+    # Returns true if there is an initial state dump
+    def has_initial_state?
+        !!Autorespawn.slave_initial_state_fd
+    end
+
+    # Loads the initial state from STDIN
+    def load_initial_state
+        io = IO.for_fd(Autorespawn.slave_initial_state_fd)
+        @program_id = Marshal.load(io)
+        io.close
+    end
+
+    # Requires one file under the autorespawn supervision
+    #
+    # If the require fails, the call to {.run} will not execute its block,
+    # instead waiting for the file(s) to change
+    def require(file)
+        watch_yield { Kernel.require file }
+    end
+
+    # Call to require a bunch of files in a block and add the result to the list of watches
+    def watch_yield
+        current = currently_loaded_files
+        new_exceptions = Array.new
+        begin
+            result = yield
+        rescue Interrupt, SystemExit
+            raise
+        rescue Exception => e
+            new_exceptions << e
+            exceptions << e
+            backtrace = e.backtrace_locations.map { |l| Pathname.new(l.absolute_path) }
+            error_paths.merge(backtrace)
+            if e.kind_of?(LoadError)
+                error_paths << e.path
+            end
+        end
+        required_paths.merge(currently_loaded_files - current)
+        return result, new_exceptions
+    end
+
+    # Returns whether we have been spawned by a manager, or in standalone mode
+    def slave?
+        self.class.slave?
+    end
+
+    # Request that the master spawns these subcommands
+    #
+    # @raise [NotSlave] if the script is being executed in standalone mode
+    def add_slave(*cmdline, **spawn_options)
+        subcommands << [cmdline, spawn_options]
+    end
+
+    # Create a pipe and dump the program ID state of the current program
+    # there
+    def dump_initial_state(files)
+        program_id = ProgramID.new
+        program_id.register_files(files)
+
+        io = Tempfile.new "autorespawn_initial_state"
+        Marshal.dump(program_id, io)
+        io.flush
+        io.rewind
+        io
+    end
+
+    def currently_loaded_files
+        $LOADED_FEATURES.map { |p| Pathname.new(p) } +
+            caller_locations.map { |l| Pathname.new(l.absolute_path) }
+    end
+        
+    # Declares a handler that should be called in a process, just before
+    # exec'ing a fresh process *if* the block has been executed
+    def at_respawn(&block)
+        respawn_handlers << block
+    end
+
+    # Defines the exit code for this instance
+    def exit_code(value = nil)
+        if value
+            @exit_code = value
+        else
+            @exit_code
+        end
+    end
+
+    # Perform the program workd and reexec it when needed
+    #
+    # It is the last method you should be calling in your program, providing the
+    # program's actual work in the block. Once the block return, the method will
+    # watch for changes and reexec's it 
+    #
+    # Exceptions raised by the block are displayed but do not cause the watch to
+    # stop
+    #
+    # This method does NOT return
+    def run(&block)
+        if slave? || subcommands.empty?
+            all_files = required_paths | error_paths
+            if block_given? 
+                all_files = perform_work(all_files, &block)
+            end
+
+            if slave?
+                io = IO.for_fd(Autorespawn.slave_result_fd)
+                string = Marshal.dump([subcommands, all_files])
+                io.write string
+                io.flush
+                exit exit_code
+            else
+                io = dump_initial_state(all_files)
+                Kernel.exec(Hash[SLAVE_INITIAL_STATE_ENV => "#{io.fileno}"], *process_command_line[0],
+                            io.fileno => io.fileno, **process_command_line[1])
+            end
+        else
+            if block_given?
+                raise ArgumentError, "cannot call #run with a block after using #add_slave"
+            end
+            manager = Manager.new
+            subcommands.each do |command, options|
+                manager.add_slave(*command, **options)
+            end
+            return manager.run
+        end
+    end
+
+    # @api private
+    def perform_work(all_files, &block)
+        if has_initial_state?
+            load_initial_state
+        end
+
+        not_tracked = all_files.
+            find_all do |p|
+                begin !program_id.include?(p)
+                rescue FileNotFound
+                end
+            end
+
+        if not_tracked.empty? && !program_id.changed?
+            if exceptions.empty?
+                did_yield = true
+                _, yield_exceptions = watch_yield(&block)
+                yield_exceptions.each do |e|
+                    backtrace = (e.backtrace || Array.new).dup
+                    first_line = backtrace.shift
+                    STDERR.puts "#{e.message}: #{first_line}"
+                    STDERR.puts "  #{e.backtrace.join("\n  ")}"
+                end
+
+            end
+
+            all_files = required_paths | error_paths
+            not_tracked = all_files.
+                find_all do |p|
+                    begin !program_id.include?(p)
+                    rescue FileNotFound
+                    end
+                end
+
+            if !slave? && not_tracked.empty?
+                Watch.new(program_id).wait
+            end
+            if did_yield
+                respawn_handlers.each { |b| b.call }
+            end
+        end
+        all_files
+    end
+
+    def self.run(*command, **options, &block)
+        new(*command, **options).run(&block)
+    end
 end
+

data/lib/autorespawn/exceptions.rb

@@ -1,4 +1,4 @@
-module Autorespawn
+class Autorespawn
     # Exception raised when a path cannot be resolved to a file on disk
     class FileNotFound < RuntimeError
         # @return [Pathname] the path to resolve
@@ -11,4 +11,18 @@ module Autorespawn
             @path, @search_path = path, search_path
         end
     end
+
+    # Exception raised when a command that is only available in master/slave
+    # mode is called in standalone mode
+    class NotSlave < RuntimeError
+    end
+
+    # Exception raised when a command that is only available in master/slave
+    # mode is called in standalone mode
+    class NotFinished < RuntimeError
+    end
+
+    # Exception raised in Slave#spawn if the slave is already running
+    class AlreadyRunning < RuntimeError
+    end
 end

data/lib/autorespawn/manager.rb

@@ -0,0 +1,77 @@
+class Autorespawn
+    # Manager of a bunch of autorespawn slaves
+    class Manager
+        # @param [Integer] the number of processes allowed to work in parallel
+        attr_reader :parallel_level
+        # @return [Array<Slave>] declared worker processes, as a hash from
+        #   the PID to a Slave object
+        attr_reader :workers
+        # @return [Hash<Slave>] list of active slaves
+        attr_reader :active_slaves
+
+        def initialize(parallel_level: 1)
+            @parallel_level = parallel_level
+            @workers   = Array.new
+            @active_slaves = Hash.new
+        end
+
+        # Spawns a worker, i.e. a program that will perform the intended work
+        # and report the program state
+        def add_slave(*cmdline, **spawn_options)
+            slave = Slave.new(*cmdline, **spawn_options)
+            workers << slave
+            slave
+        end
+
+        # @api private
+        #
+        # Collect information about the finished slaves
+        #
+        # @return [Array<Slave>] the slaves that finished
+        def collect_finished_slaves
+            finished_slaves = Array.new
+            while finished_child = Process.waitpid2(-1, Process::WNOHANG)
+                pid, status = *finished_child
+                if slave = active_slaves.delete(pid)
+                    finished_slaves << slave
+                    slave.finished(status)
+                end
+            end
+            finished_slaves
+        rescue Errno::ECHILD
+            Array.new
+        end
+
+        def run
+            while true
+                poll
+                sleep 1
+            end
+
+        rescue Interrupt
+        ensure
+            active_slaves.values.each do |slave|
+                slave.kill
+            end
+        end
+
+        # Wait for children to terminate and spawns them when needed
+        def poll
+            finished_slaves = collect_finished_slaves
+            new_slaves = Array.new
+            while active_slaves.size < parallel_level
+                if slave_i = workers.index { |s| s.needs_spawn? }
+                    slave = workers.delete_at(slave_i)
+                    @workers = workers[slave_i..-1] + workers[0, slave_i] + [slave]
+                    slave.spawn
+                    new_slaves << slave
+                    active_slaves[slave.pid] = slave
+                else
+                    break
+                end
+            end
+            return new_slaves, finished_slaves
+        end
+    end
+end
+

data/lib/autorespawn/program_id.rb

@@ -2,7 +2,7 @@ require 'autorespawn/program_id'
 require 'pathname'
 require 'digest/sha1'
 
-module Autorespawn
+class Autorespawn
     # Management of the ID of a complete Ruby program
     #
     # It basically stores information about all the files that form this
@@ -26,6 +26,16 @@ module Autorespawn
             id
         end
 
+        # Whether this program ID tracks some files
+        def empty?
+            files.empty?
+        end
+
+        # Remove all tracked files
+        def clear
+            files.clear
+        end
+
         # Registers the file information for all loaded features
         # 
         # @return [void]
@@ -44,15 +54,61 @@ module Autorespawn
             end
         end
 
+        # Register a set of files
+        #
+        # @param [Array<String>] files the list of files
+        # @param [Array<String>] search_path the path to resolve relative paths
+        # @param [Boolean] ignore_not_found whether files that cannot be
+        #   resolved are ignored or cause a FileNotFound exception
+        # @return [Boolean] whether the program ID has been modified
+        def register_files(files, search_path = ruby_load_path, ignore_not_found: true)
+            modified = Array.new
+            files.each do |path|
+                begin
+                    if full_path = register_file(path, search_path)
+                        modified << full_path
+                    end
+                rescue FileNotFound
+                    raise if !ignore_not_found
+                end
+            end
+            modified
+        end
+
         # Registers file information for one file
         #
         # @param [Pathname] file the path to the file
-        # @return [FileInfo] the file's information
+        # @return [Boolean] whether the registration modified the program ID's
+        #   state
         def register_file(file, search_path = ruby_load_path)
             info = file_info(file, search_path)
+            modified = (files[info.path] != info)
             files[info.path] = info
+
+            if modified
+                @id = nil 
+                info.path
+            end
+        end
+
+        # Update the information about all the files registered on this object
+        def refresh
+            updated = Hash.new
+            files.each_key do |path|
+                next if !path.exist?
+                info = file_info(path)
+                updated[info.path] = info
+            end
+            @files = updated
             @id = nil
-            info
+            updated
+        end
+
+        # Enumerate the path of all the files that are being tracked
+        #
+        # @yieldparam [Pathname] path
+        def each_tracked_file(&block)
+            files.keys.each(&block)
         end
 
         # Returns a string that can ID this program
@@ -78,6 +134,10 @@ module Autorespawn
             false
         end
 
+        def include?(path, search_path = ruby_load_path)
+            files.has_key?(resolve_file_path(path, search_path))
+        end
+
         # @api private
         #
         # Given a path that may be relative, computes the full path to the

data/lib/autorespawn/slave.rb

@@ -0,0 +1,178 @@
+class Autorespawn
+    # Representation of an autorespawn-aware subprocess that is started by a
+    # {Manager}
+    #
+    # Slaves have two roles: the one of discovery (what are the commands that
+    # need to be started) and the one of 
+    class Slave
+        # The currently known program ID
+        attr_reader :program_id
+        # The command line of the subprocess
+        attr_reader :cmdline
+        # Environment that should be set in the subprocess
+        attr_reader :spawn_env
+        # Options that should be passed to Kernel.spawn
+        attr_reader :spawn_options
+        # @return [nil,Integer] pid the PID of the current process or of the
+        #   last process if it is finished. It is non-nil only after {#spawn} has
+        #   been called
+        attr_reader :pid
+        # @return [Process::Status] the exit status of the last run. Is nil
+        #   while the process is running
+        attr_reader :status
+
+        # @return [Array<String>] a list of commands that this slave requests
+        attr_reader :subcommands
+
+        # @api private
+        #
+        # @return [IO] the result I/O
+        attr_reader :result_r
+        # @api private
+        #
+        # @return [String] the result data as received
+        attr_reader :result_buffer
+
+        def initialize(*cmdline, env: Hash.new, **spawn_options)
+            @program_id = ProgramID.new
+            @cmdline    = cmdline
+            @needs_spawn = true
+            @spawn_env     = env
+            @spawn_options = spawn_options
+            @subcommands = Array.new
+            @pid        = nil
+            @status     = nil
+            @result_r  = nil
+            @result_buffer = nil
+        end
+
+        def inspect
+            "#<Autorespawn::Slave #{object_id.to_s(16)} #{cmdline.join(" ")}>"
+        end
+
+        def to_s; inspect end
+
+        # Start the slave
+        #
+        # @return [Integer] the slave's PID
+        def spawn
+            if running?
+                raise AlreadyRunning, "cannot call #spawn on #{self}: already running"
+            end
+
+            initial_r, initial_w = IO.pipe
+            result_r, result_w = IO.pipe
+            env = self.spawn_env.merge(
+                SLAVE_INITIAL_STATE_ENV => initial_r.fileno.to_s,
+                SLAVE_RESULT_ENV        => result_w.fileno.to_s)
+
+            program_id.refresh
+            @needs_spawn = false
+            pid = Kernel.spawn(env, *cmdline, initial_r => initial_r, result_w => result_w, **spawn_options)
+            initial_r.close
+            result_w.close
+            Marshal.dump(program_id, initial_w)
+
+            @pid = pid
+            @status = nil
+            @result_buffer = ''
+            @result_r = result_r
+            pid
+
+        rescue Exception => e
+            if pid
+                Process.kill 'TERM', pid
+            end
+            result_r.close if result_r && !result_r.closed?
+            raise
+
+        ensure
+            initial_r.close if initial_r && !initial_r.closed?
+            initial_w.close if initial_w && !initial_r.closed?
+            result_w.close  if result_w && !result_w.closed?
+        end
+
+        # Whether this slave would need to be spawned, either because it has
+        # never be, or because the program ID changed
+        def needs_spawn?
+            @needs_spawn || !status || program_id.changed?
+        end
+
+        # Whether the slave is running
+        def running?
+            pid && !status
+        end
+
+        # Whether the slave has already ran, and is finished
+        def finished?
+            pid && status
+        end
+
+        # Kill the slave
+        #
+        # @param [Boolean] join whether the method should wait for the child to
+        #   end
+        # @see join
+        def kill(signal = 'TERM', join: true)
+            Process.kill signal, pid
+            if join
+                self.join
+            end
+        end
+
+        # Wait for the slave to terminate and call {#finished}
+        def join
+            _, status = Process.waitpid2(pid)
+            finished(status)
+        end
+
+        # Whether the slave behaved properly
+        #
+        # This does *not* indicate whether the slave's intended work has been
+        # done, only that it produced the data expected by Autorespawn. To check
+        # the child's success w.r.t. its execution, check {#status}
+        def success?
+            if !status
+                raise NotFinished, "called {#success?} on a #{pid ? 'running' : 'non-started'} child"
+            end
+            @success
+        end
+
+        # @api private
+        #
+        # Announce that the slave already finished, with the given exit status
+        #
+        # @param [Process::Status] the exit status
+        def finished(status)
+            @status = status
+            read_queued_result
+            begin
+                @subcommands, file_list = Marshal.load(result_buffer)
+                @success = true
+            rescue ArgumentError # "Marshal data too short"
+                @subcommands = Array.new
+                file_list = Array.new
+                @success = false
+            end
+            modified = program_id.register_files(file_list)
+            if !modified.empty?
+                @needs_spawn = true
+            end
+            result_r.close
+            modified
+        end
+
+        # @api private
+        #
+        # Queue any pending result data sent by the slave
+        def read_queued_result
+            while true
+                result_buffer << result_r.read_nonblock(1024)
+            end
+        rescue IO::WaitReadable, EOFError
+        end
+    end
+end
+
+
+

data/lib/autorespawn/version.rb

@@ -1,3 +1,3 @@
-module Autorespawn
-  VERSION = "0.1.0"
+class Autorespawn
+    VERSION = "0.2.0"
 end

data/lib/autorespawn/watch.rb

@@ -1,69 +1,6 @@
-module Autorespawn
+class Autorespawn
     # Functionality to watch a program for change
     class Watch
-        # Create a pipe and dump the program ID state of the current program
-        # there
-        def self.dump_self_id
-            r, w = IO.pipe
-            Marshal.dump(ProgramID.for_self, w)
-            w.flush
-            return r, w
-        end
-
-        # Automatically autoreload this program when one of the source file
-        # changes
-        #
-        # Call this method from the entry point of your program, giving it the
-        # actual program functionality as a block. The method will exec and
-        # spawn subprocesses at will, when needed, and call the block in these
-        # subprocesses as required.
-        #
-        # At the point of call, all of the program's dependencies must be
-        # already required, as it is on this basis that the auto-reloading will
-        # be done
-        #
-        # This method does NOT return
-        #
-        # @param [Array<String>] command the command to be executed. It is
-        #   passed as-is to Kernel.spawn and Kernel.exec
-        # @param options keyword options to pass to Kernel.spawn and Kernel.exec
-        def self.autoreload(*command, **options)
-            if !block_given?
-                raise ArgumentError, "you must provide the actions to perform on reload as a block"
-            end
-
-            # Check if we're being called by an autoreload call already
-            if ENV['autorespawn_AUTORELOAD']
-                program_id = Marshal.load(STDIN)
-                if !program_id.changed?
-                    # We can do what is required of us and wait for changes
-                    yield
-                    new(program_id).wait
-                end
-
-                r, w = dump_self_id
-                exec(Hash['autorespawn_AUTORELOAD' => '1'], *command,
-                     in: r, **options)
-            else
-                begin
-                    r, w = dump_self_id
-                    pid = spawn(Hash['autorespawn_AUTORELOAD' => '1'], *command,
-                                in: r, pgroup: true, **options)
-                    w.close
-                    r.close
-                    _, status = Process.waitpid2(pid)
-                    exit status.exitcode
-                ensure
-                    if pid
-                        Process.kill 'TERM', pid
-                    end
-                    if !$!
-                        exit 0
-                    end
-                end
-            end
-        end
-
         # @return [ProgramID] the reference state
         attr_reader :current_state
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: autorespawn
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Sylvain Joyeux
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2015-09-12 00:00:00.000000000 Z
+date: 2015-09-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -98,6 +98,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: coveralls
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: |
   This gem implements the functionality to take a signature of the current Ruby
   program (i.e. the current process) and respawn it whenever the source code or
@@ -117,7 +131,9 @@ files:
 - autorespawn.gemspec
 - lib/autorespawn.rb
 - lib/autorespawn/exceptions.rb
+- lib/autorespawn/manager.rb
 - lib/autorespawn/program_id.rb
+- lib/autorespawn/slave.rb
 - lib/autorespawn/version.rb
 - lib/autorespawn/watch.rb
 homepage: https://github.com/doudou/autorespawn
@@ -132,7 +148,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 2.1.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
@@ -145,3 +161,4 @@ signing_key:
 specification_version: 4
 summary: functionality to respawn a Ruby program when its source changes
 test_files: []
+has_rdoc: