zeus 0.2.6 → 0.3.0

data/.zeus.rb

@@ -0,0 +1,11 @@
+Zeus::Server.define! do
+
+  stage :zeus do
+    action { require 'zeus' ; require 'rspec' ; require 'rspec/core/runner' }
+
+    command :spec, :s do
+      RSpec::Core::Runner.autorun
+    end
+  end
+
+end

data/lib/thrud.rb

@@ -45,7 +45,7 @@ class Thrud
   def help(taskname = nil)
     if taskname && task = task_for_name(taskname)
       arity = task.arity(self)
-      puts <<-BANNER
+      Zeus.ui.info <<-BANNER
 Usage:
   zeus #{taskname} #{arity == -1 ? "[ARGS]" : ""}
 
@@ -61,7 +61,7 @@ BANNER
         "  zeus %-14s # %s" % [task.method_name, task.desc]
       }
 
-      puts <<-BANNER
+      Zeus.ui.info <<-BANNER
 Global Commands:
   zeus help           # show this help menu
   zeus help [COMMAND] # show help for a specific command

data/lib/zeus.rb

@@ -22,4 +22,14 @@ module Zeus
     @ui = ui
   end
 
+  def self.after_fork(&b)
+    @after_fork ||= []
+    @after_fork << b
+  end
+
+  def self.run_after_fork!
+    @after_fork.map(&:call) if @after_fork
+    @after_fork = []
+  end
+
 end

data/lib/zeus/cli.rb

@@ -65,16 +65,16 @@ module Zeus
 
     begin
       require definition_file
-      Zeus::Server.acceptors.each do |acc|
-        desc acc.name, (acc.description || "#{acc.name} task defined in .zeus.rb")
-        define_method(acc.name) { |*args|
-          Zeus::Client.run(acc.name, args)
-        }
-        map acc.aliases => acc.name
-      end
     rescue LoadError
     end
 
+    Zeus::Server.acceptors.each do |acc|
+      desc acc.name, (acc.description || "#{acc.name} task defined in zeus definition file")
+      define_method(acc.name) { |*args|
+        Zeus::Client.run(acc.name, args)
+      }
+      map acc.aliases => acc.name
+    end
 
   end
 end

data/lib/zeus/client.rb

@@ -63,7 +63,11 @@ module Zeus
     def handle_winch
       @winch.read(1)
       set_winsize
-      Process.kill("WINCH", pid) if pid
+      begin
+        Process.kill("WINCH", pid) if pid
+      rescue Errno::ESRCH
+        exit # the remote process died. Just quit.
+      end
     end
 
     def handle_stdin(buffer)
@@ -72,8 +76,7 @@ module Zeus
         begin
           Process.kill(SIGNALS[signal], pid)
         rescue Errno::ESRCH
-          # we're trying to kill a process that died. Just quit.
-          exit
+          exit # the remote process died. Just quit.
         end
       }
       @master << input

data/lib/zeus/server.rb

@@ -1,8 +1,10 @@
 require 'json'
 require 'socket'
+require 'forwardable'
 
 module Zeus
   class Server
+    extend Forwardable
 
     autoload :Stage,                       'zeus/server/stage'
     autoload :Acceptor,                    'zeus/server/acceptor'
@@ -19,7 +21,7 @@ module Zeus
     end
 
     def self.acceptors
-      @@definition.acceptors
+      defined?(@@definition) ? @@definition.acceptors : []
     end
 
     def initialize
@@ -58,29 +60,19 @@ module Zeus
       File.unlink(Zeus::SOCKET_NAME)
     end
 
-    module ChildProcessApi
 
-      def __CHILD__close_parent_sockets
-        monitors.each(&:close_parent_socket)
-      end
-
-      def __CHILD__pid_has_ppid(pid, ppid)
-        @process_tree_monitor.__CHILD__send_pid("#{pid}:#{Process.ppid}")
-      end
-
-      def __CHILD__pid_has_feature(pid, feature)
-        @process_tree_monitor.__CHILD__send_feature("#{pid}:#{feature}")
-      end
-
-      def __CHILD__register_acceptor(io)
-        @acceptor_registration_monitor.__CHILD__register_acceptor(io)
-      end
+    # Child process API
+    def __CHILD__close_parent_sockets
+      monitors.each(&:close_parent_socket)
+    end
 
-      def __CHILD__find_acceptor_for_command(command)
-        @acceptor_registration_monitor.__CHILD__find_acceptor_for_command(command)
-      end
+    def_delegators :@acceptor_registration_monitor,
+      :__CHILD__register_acceptor,
+      :__CHILD__find_acceptor_for_command
 
-    end ; include ChildProcessApi
+    def_delegators :@process_tree_monitor,
+      :__CHILD__pid_has_ppid,
+      :__CHILD__pid_has_feature
 
   end
 end

data/lib/zeus/server/acceptor.rb

@@ -36,6 +36,13 @@ module Zeus
         ARGV.replace(arguments)
 
         @action.call
+      ensure
+        dnw, dnr = File.open("/dev/null", "w+"), File.open("/dev/null", "r+")
+        $stdin.reopen(dnw)
+        $stdout.reopen(dnr)
+        $stderr.reopen(dnr)
+        terminal.close
+        exit 0
       end
 
       private
@@ -70,8 +77,8 @@ module Zeus
 
       def postfork_action! # TODO :refactor
         ActiveRecord::Base.establish_connection   rescue nil
-        ActiveSupport::DescendantsTracker.clear   rescue nil
-        ActiveSupport::Dependencies.clear         rescue nil
+        # ActiveSupport::DescendantsTracker.clear   rescue nil
+        # ActiveSupport::Dependencies.clear         rescue nil
       end
 
     end

data/lib/zeus/server/acceptor_error_state.rb

@@ -4,7 +4,7 @@ require 'socket'
 # See Zeus::Server::ClientHandler for relevant documentation
 module Zeus
   class Server
-    module ErrorStateAcceptor
+    module AcceptorErrorState
       attr_accessor :error
 
       def print_error(io, error = @error)
@@ -16,7 +16,7 @@ module Zeus
 
       def run
         register_with_client_handler(Process.pid)
-        Zeus.ui.as_zeus "starting error-state acceptor `#{@name}`"
+        Zeus.ui.info "starting error-state acceptor `#{@name}`"
 
         Thread.new do
           loop do

data/lib/zeus/server/client_handler.rb

@@ -29,112 +29,101 @@ module Zeus
       def close_child_socket  ; end
       def close_parent_socket ; @listener.close ; end
 
+      REATTEMPT_HANDSHAKE = 204
+
       def initialize(acceptor_commands, server)
         @server = server
         @acceptor_commands = acceptor_commands
         @listener = UNIXServer.new(Zeus::SOCKET_NAME)
         @listener.listen(10)
       rescue Errno::EADDRINUSE
-        Zeus.ui.error "Zeus appears to be already running in this project. If not, remove .zeus.sock and try again."
+        Zeus.ui.error "Zeus appears to be already running in this project. If not, remove #{Zeus::SOCKET_NAME} and try again."
         exit 1
       end
 
+      private
+
+      #  client clienthandler acceptor
+      # 1  ---------->                | {command: String, arguments: [String]}
+      # 2  ---------->                | Terminal IO
+      # 3            ----------->     | Terminal IO
+      # 4            ----------->     | Arguments (json array)
+      # 5            <-----------     | pid
+      # 6  <---------                 | pid
       def handle_server_connection
         s_client = @listener.accept
 
-        # 1
-        data = JSON.parse(s_client.readline.chomp)
+        data = JSON.parse(s_client.readline.chomp) # step 1
         command, arguments = data.values_at('command', 'arguments')
 
-        # 2
-        client_terminal = s_client.recv_io
+        client_terminal = s_client.recv_io # step 2
 
         Thread.new {
-          loop do
-            pid = fork { handshake_client_to_acceptor(s_client, command, arguments, client_terminal) ; exit }
-            Process.wait(pid)
-            break unless $?.exitstatus == REATTEMPT_HANDSHAKE
+          # This is a little ugly. Gist: Try to handshake the client to the acceptor.
+          # If the acceptor is not booted yet, this will hang until it is, then terminate with 
+          # REATTEMPT_HANDSHAKE. We catch that exit code and try once more.
+          begin
+            loop do
+              pid = fork { handshake_client_to_acceptor(s_client, command, arguments, client_terminal) ; exit }
+              Process.wait(pid)
+              break if $?.exitstatus != REATTEMPT_HANDSHAKE
+            end
+          ensure
+            client_terminal.close
+            s_client.close
           end
         }
       end
 
-      REATTEMPT_HANDSHAKE = 204
+      def handshake_client_to_acceptor(s_client, command, arguments, client_terminal)
+        unless @acceptor_commands.include?(command.to_s)
+          msg = "no such command `#{command}`."
+          return exit_with_message(s_client, client_terminal, msg)
+        end
+
+        unless acceptor = send_io_to_acceptor(client_terminal, command) # step 3
+          wait_for_acceptor(s_client, client_terminal, command)
+          exit REATTEMPT_HANDSHAKE
+        end
 
-      NoSuchCommand = Class.new(Exception)
-      AcceptorNotBooted = Class.new(Exception)
-      ApplicationLoadFailed = Class.new(Exception)
+        Zeus.ui.info "accepting connection for #{command}"
+
+        acceptor.socket.puts arguments.to_json # step 4
+        pid = acceptor.socket.readline.chomp.to_i # step 5
+        s_client.puts pid # step 6
+        s_client.close
+      end
 
       def exit_with_message(s_client, client_terminal, msg)
         s_client << "0\n"
         client_terminal << "[zeus] #{msg}\n"
         client_terminal.close
         s_client.close
+        exit 1
       end
 
-      def wait_for_acceptor(s_client, client_terminal, command, msg)
+      def wait_for_acceptor(s_client, client_terminal, command)
         s_client << "0\n"
-        client_terminal << "[zeus] #{msg}\n"
-
-        regmsg = {type: 'wait', command: command}
+        client_terminal << "[zeus] waiting for `#{command}` to finish booting...\n"
 
         s, r = UNIXSocket.pair
-
+        s << {type: 'wait', command: command}.to_json << "\n"
         @server.__CHILD__register_acceptor(r)
-        s << "#{regmsg.to_json}\n"
-
-        s.readline # wait
-        s.close
 
-        exit REATTEMPT_HANDSHAKE
+        s.readline # wait until acceptor is booted
       end
 
-      #  client clienthandler acceptor
-      # 1  ---------->                | {command: String, arguments: [String]}
-      # 2  ---------->                | Terminal IO
-      # 3            ----------->     | Terminal IO
-      # 4            ----------->     | Arguments (json array)
-      # 5            <-----------     | pid
-      # 6  <---------                 | pid
-      def handshake_client_to_acceptor(s_client, command, arguments, client_terminal)
-        # 3
-        unless @acceptor_commands.include?(command.to_s)
-          return exit_with_message(
-            s_client, client_terminal,
-            "no such command `#{command}`.")
-        end
-        acceptor = @server.__CHILD__find_acceptor_for_command(command)
-        unless acceptor
-          wait_for_acceptor(
-            s_client, client_terminal, command,
-            "waiting for `#{command}` to finish booting...")
-        end
-        usock = UNIXSocket.for_fd(acceptor.socket.fileno)
-        if usock.closed?
-          wait_for_acceptor(
-            s_client, client_terminal, command,
-            "waiting for `#{command}` to finish reloading dependencies...")
-        end
-        begin
-          usock.send_io(client_terminal)
-        rescue Errno::EPIPE
-          wait_for_acceptor(
-            s_client, client_terminal, command,
-            "waiting for `#{command}` to finish reloading dependencies...")
-        end
-
-
-        Zeus.ui.info "accepting connection for #{command}"
-
-        # 4
-        acceptor.socket.puts arguments.to_json
-
-        # 5
-        pid = acceptor.socket.readline.chomp.to_i
-
-        # 6
-        s_client.puts pid
+      def send_io_to_acceptor(io, command)
+        return false unless acceptor = @server.__CHILD__find_acceptor_for_command(command)
+        return false unless usock = UNIXSocket.for_fd(acceptor.socket.fileno)
+        usock.send_io(io)
+        io.close
+        return acceptor
+      rescue Errno::EPIPE
+        return false
       end
 
+
     end
   end
 end

data/lib/zeus/server/file_monitor/fsevent.rb

@@ -1,4 +1,5 @@
 require 'open3'
+require 'pathname'
 
 module Zeus
   class Server
@@ -13,41 +14,69 @@ module Zeus
 
         def initialize(&change_callback)
           @change_callback = change_callback
-          @io_in, @io_out, _ = Open3.popen2e(WRAPPER_PATH)
-          @watched_files = {}
+          @io_in, @io_out, _ = open_wrapper
+          @givenpath_to_realpath = {}
+          @realpath_to_givenpath = {}
           @buffer = ""
         end
 
+        # The biggest complicating factor here is that ruby doesn't fully resolve
+        # symlinks in paths, but FSEvents does. We resolve all paths fully with
+        # Pathname#realpath, and keep mappings in both directions.
+        # It's conceivable that the same file would be required by two different paths,
+        # so we keep an array and fire callbacks for all given paths matching a real
+        # path when a change is detected.
+        def watch(given)
+          return false if @givenpath_to_realpath[given]
+
+          real = realpath(given)
+          @givenpath_to_realpath[given] = real
+          @realpath_to_givenpath[real] ||= []
+          @realpath_to_givenpath[real] << given
+
+          @io_in.puts real
+          true
+        end
+
+        private
+
+        def realpath(file)
+          Pathname.new(file).realpath.to_s
+        rescue Errno::ENOENT
+          file
+        end
+
+        def open_wrapper
+          Open3.popen2e(WRAPPER_PATH)
+        end
+
         def handle_changed_files
           50.times { read_and_notify_files }
         rescue Errno::EAGAIN
         end
 
         def read_and_notify_files
-          lines = @io_out.read_nonblock(30000)
+          lines = @io_out.read_nonblock(1000)
           files = lines.split("\n")
           files[0] = "#{@buffer}#{files[0]}" unless @buffer == ""
           unless lines[-1] == "\n"
             @buffer = files.pop
           end
 
-          files.each do |file|
-            file_did_change(file)
+          files.each do |real|
+            file_did_change(real)
           end
         end
 
-        def watch(file)
-          return false if @watched_files[file]
-          @watched_files[file] = true
-          @io_in.puts file
-          true
+        def file_did_change(real)
+          realpaths_for_givenpath(real).each do |given|
+            Zeus.ui.info("Dependency change at #{given}")
+            @change_callback.call(given)
+          end
         end
 
-        private
-
-        def file_did_change(file)
-          Zeus.ui.info("Dependency change at #{file}")
-          @change_callback.call(file)
+        def realpaths_for_givenpath(real)
+          @realpath_to_givenpath[real] || []
         end
 
       end

data/lib/zeus/server/forked_process.rb

@@ -27,17 +27,23 @@ module Zeus
 
         $0 = "zeus #{process_type}: #{@name}"
 
-        Zeus.ui.as_zeus("starting #{process_type} `#{@name}`")
+        Zeus.ui.info("starting #{process_type} `#{@name}`")
         trap("INT") {
-          Zeus.ui.as_zeus("killing #{process_type} `#{@name}`")
+          Zeus.ui.info("killing #{process_type} `#{@name}`")
           exit 0
         }
 
+        new_features = $LOADED_FEATURES - previously_loaded_features
+        $previously_loaded_features = $LOADED_FEATURES.dup
         Thread.new {
-          $LOADED_FEATURES.each { |f| notify_feature(f) }
+          new_features.each { |f| notify_feature(f) }
         }
       end
 
+      def previously_loaded_features
+        defined?($previously_loaded_features) ? $previously_loaded_features : []
+      end
+
       def kill_pid_on_exit(pid)
         currpid = Process.pid
         at_exit { Process.kill(9, pid) if Process.pid == currpid rescue nil }
@@ -57,6 +63,9 @@ module Zeus
         @pid = fork {
           before_setup
           setup_forked_process(close_parent_sockets)
+
+          Zeus.run_after_fork!
+
           after_setup
           runloop!
         }

data/lib/zeus/server/process_tree.rb

@@ -1,43 +1,12 @@
 module Zeus
   class Server
     class ProcessTree
-      class Node
-        attr_accessor :pid, :children, :features
-        def initialize(pid)
-          @pid, @children, @features = pid, [], {}
-        end
-
-        def add_child(node)
-          self.children << node
-        end
-
-        def add_feature(feature)
-          self.features[feature] = true
-        end
-
-        def has_feature?(feature)
-          self.features[feature] == true
-        end
-
-        def inspect
-          "(#{pid}:#{features.size}:[#{children.map(&:inspect).join(",")}])"
-        end
-
-      end
-
-      def inspect
-        @root.inspect
-      end
 
       def initialize
         @root = Node.new(Process.pid)
         @nodes_by_pid = {Process.pid => @root}
       end
 
-      def node_for_pid(pid)
-        @nodes_by_pid[pid.to_i] ||= Node.new(pid.to_i)
-      end
-
       def process_has_parent(pid, ppid)
         curr = node_for_pid(pid)
         base = node_for_pid(ppid)
@@ -49,20 +18,9 @@ module Zeus
         node.add_feature(feature)
       end
 
-      def kill_node(node)
-        @nodes_by_pid.delete(node.pid)
-        # recall that this process explicitly traps INT -> exit 0
-        Process.kill("INT", node.pid)
-      end
-
       def kill_nodes_with_feature(file, base = @root)
         if base.has_feature?(file)
-          if base == @root.children[0] || base == @root
-            Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
-            return false
-          end
           kill_node(base)
-          return true
         else
           base.children.dup.each do |node|
             if kill_nodes_with_feature(file, node)
@@ -73,6 +31,46 @@ module Zeus
         end
       end
 
+      private
+
+      def node_for_pid(pid)
+        @nodes_by_pid[pid.to_i] ||= Node.new(pid.to_i)
+      end
+
+      def kill_node(node)
+        if node == @root.children[0] || node == @root
+          Zeus.ui.error "One of zeus's dependencies changed. Not killing zeus. You may have to restart the server."
+          return false
+        end
+        @nodes_by_pid.delete(node.pid)
+        node.kill
+      end
+
+      class Node
+        attr_accessor :pid, :children, :features
+        def initialize(pid)
+          @pid, @children, @features = pid, [], {}
+        end
+
+        def kill
+          # recall that this process explicitly traps INT -> exit 0
+          Process.kill("INT", pid)
+        end
+
+        def add_child(node)
+          self.children << node
+        end
+
+        def add_feature(feature)
+          self.features[feature] = true
+        end
+
+        def has_feature?(feature)
+          self.features[feature] == true
+        end
+
+      end
+
     end
   end
 end

data/lib/zeus/server/process_tree_monitor.rb

@@ -9,34 +9,55 @@ module Zeus
       def close_child_socket  ; @__CHILD__sock.close ; end
       def close_parent_socket ; @sock.close ; end
 
-      def initialize(file_monitor)
-        @tree = ProcessTree.new
+      def initialize(file_monitor, tree=ProcessTree.new)
+        @tree = tree
         @file_monitor = file_monitor
 
-        @sock, @__CHILD__sock = Socket.pair(:UNIX, :DGRAM)
+        @sock, @__CHILD__sock = open_socketpair
       end
 
       def kill_nodes_with_feature(file)
         @tree.kill_nodes_with_feature(file)
       end
 
+      module ChildProcessApi
+        def __CHILD__pid_has_ppid(pid, ppid)
+          @__CHILD__sock.send("#{PID_TYPE}:#{pid}:#{ppid}", 0)
+        rescue Errno::ENOBUFS
+          sleep 0.2
+          retry
+        end
+
+        def __CHILD__pid_has_feature(pid, feature)
+          @__CHILD__sock.send("#{FEATURE_TYPE}:#{pid}:#{feature}", 0)
+        rescue Errno::ENOBUFS
+          sleep 0.2
+          retry
+        end
+      end ; include ChildProcessApi
+
+
+      private
+
       def handle_messages
         50.times { handle_message }
       rescue Errno::EAGAIN
       end
 
       def handle_message
-        data = @sock.recv_nonblock(1024)
+        data = @sock.recv_nonblock(4096)
         case data[0]
         when FEATURE_TYPE
           handle_feature_message(data[1..-1])
         when PID_TYPE
           handle_pid_message(data[1..-1])
-        else
-          raise "Unrecognized message"
         end
       end
 
+      def open_socketpair
+        Socket.pair(:UNIX, :DGRAM)
+      end
+
       def handle_pid_message(data)
         data =~ /(\d+):(\d+)/
           pid, ppid = $1.to_i, $2.to_i
@@ -51,22 +72,6 @@ module Zeus
       end
 
 
-      module ChildProcessApi
-        def __CHILD__send_pid(message)
-          @__CHILD__sock.send(PID_TYPE + message, 0)
-        rescue Errno::ENOBUFS
-          sleep 0.2
-          retry
-        end
-
-        def __CHILD__send_feature(message)
-          @__CHILD__sock.send(FEATURE_TYPE + message, 0)
-        rescue Errno::ENOBUFS
-          sleep 0.2
-          retry
-        end
-      end ; include ChildProcessApi
-
     end
   end
 end

data/lib/zeus/templates/rails.rb

@@ -16,7 +16,7 @@ Zeus::Server.define! do
     stage :default_bundle do
       action { Bundler.require(:default) }
 
-      stage :dev do
+      stage :development_environment do
         action do
           Bundler.require(:development)
           Rails.env = ENV['RAILS_ENV'] = "development"
@@ -57,18 +57,30 @@ Zeus::Server.define! do
         end
       end
 
-      stage :test do
+      stage :test_environment do
         action do
-          Rails.env = ENV['RAILS_ENV'] = "test"
           Bundler.require(:test)
+
+          Rails.env = ENV['RAILS_ENV'] = 'test'
           require APP_PATH
+
+          $rails_rake_task = 'yup' # lie to skip eager loading
           Rails.application.require_environment!
+          $rails_rake_task = nil
+
+          test = File.join(ROOT_PATH, 'test')
+          $LOAD_PATH.unshift(test) unless $LOAD_PATH.include?(test)
+          $LOAD_PATH.unshift(ROOT_PATH) unless $LOAD_PATH.include?(ROOT_PATH)
         end
 
-        command :testrb do
-          (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
-            abort r.options.banner + " tests..."
-          exit r.run
+        stage :test_helper do
+          action { require 'test_helper' }
+
+          command :testrb do
+            (r = Test::Unit::AutoRunner.new(true)).process_args(ARGV) or
+              abort r.options.banner + " tests..."
+            exit r.run
+          end
         end
 
       end

data/lib/zeus/ui.rb

@@ -6,16 +6,8 @@ module Zeus
       @debug = ENV['DEBUG']
     end
 
-    def as_zeus(msg)
-      tell_me("[zeus] #{msg}",:purple)
-    end
-
     def info(msg)
-      tell_me(msg, nil) if !@quiet
-    end
-
-    def confirm(msg)
-      tell_me(msg, :green) if !@quiet
+      tell_me(msg, :magenta) if !@quiet
     end
 
     def warn(msg)
@@ -26,37 +18,37 @@ module Zeus
       tell_me(msg, :red)
     end
 
-    def be_quiet!
-      @quiet = true
+    def debug(msg)
+      tell_me(msg, nil) if debug?
     end
 
-    def debug?
-      # needs to be false instead of nil to be newline param to other methods
-      !!@debug && !@quiet
+    def be_quiet!
+      @quiet = true
     end
 
     def debug!
       @debug = true
     end
 
-    def debug(msg)
-      tell_me(msg, nil) if debug?
+    def debug?
+      !!@debug && !@quiet
     end
 
     private
+
     def tell_me(msg, color = nil)
+      puts make_message(msg, color)
+    end
+
+    def make_message(msg, color)
       msg = case color
-            when :red    ; "\x1b[31m#{msg}\x1b[0m"
-            when :green  ; "\x1b[32m#{msg}\x1b[0m"
-            when :yellow ; "\x1b[33m#{msg}\x1b[0m"
-            when :purple ; "\x1b[35m#{msg}\x1b[0m"
-            else         ; msg
+            when :red     ; "\x1b[31m#{msg}\x1b[0m"
+            when :green   ; "\x1b[32m#{msg}\x1b[0m"
+            when :yellow  ; "\x1b[33m#{msg}\x1b[0m"
+            when :magenta ; "\x1b[35m#{msg}\x1b[0m"
+            else          ; msg
             end
-      if msg[-1] == "\n"
-        puts msg
-      else
-        puts "#{msg}\n"
-      end
+      msg[-1] == "\n" ? msg : "#{msg}\n"
     end
 
 

data/lib/zeus/version.rb

@@ -1,3 +1,3 @@
 module Zeus
-  VERSION = "0.2.6"
+  VERSION = "0.3.0"
 end

data/spec/cli_spec.rb

@@ -0,0 +1,67 @@
+require 'zeus'
+
+module Zeus
+  describe CLI do
+
+    let(:ui) { stub(debug!: nil) }
+
+    before do
+      Zeus::UI.stub(new: ui)
+    end
+
+    describe "#help" do
+      it "prints a generic help menu" do
+        ui.should_receive(:info).with(/Global Commands.*zeus help.*show this help menu/m)
+        run_with_args("help")
+      end
+
+      it "prints a usage menu per command" do
+        ui.should_receive(:info).with(/Usage:.*zeus version.*version information/m)
+        run_with_args("help", "version")
+      end
+    end
+
+    describe "#start" do
+      it "starts the zeus server"
+      it "uses the rails template file if the project is missing a config file but looks like rails"
+      it "prints an error and exits if there is no config file and the project doesn't look like rails"
+    end
+
+    describe "#version" do
+      STRING_INCLUDING_VERSION = %r{#{Regexp.escape Zeus::VERSION}}
+
+      it "prints the version and exits" do
+        ui.should_receive(:info).with(STRING_INCLUDING_VERSION)
+        run_with_args("version")
+      end
+
+      it "has aliases" do
+        ui.should_receive(:info).with(STRING_INCLUDING_VERSION).twice
+        run_with_args("--version")
+        run_with_args("-v")
+      end
+
+    end
+
+    describe "#init" do
+      it "currently only generates a rails file, even if the project doesn't look like rails"
+      it "prints an error and exits if the project already has a zeus config"
+    end
+
+    describe "generated tasks" do
+      it "displays generated tasks in the help menu" do
+        ui.should_receive(:info).with(/spec/)
+        run_with_args("help")
+      end
+    end
+
+    private
+
+    def run_with_args(*args)
+      ARGV.replace(args)
+      Zeus::CLI.start
+    end
+
+  end
+end
+

data/spec/server/file_monitor/fsevent_spec.rb

@@ -0,0 +1,88 @@
+require 'socket'
+require 'tempfile'
+require 'fileutils'
+require 'securerandom'
+
+require 'zeus'
+
+module Zeus::Server::FileMonitor
+  describe FSEvent do
+
+    let(:fsevent) { FSEvent.new() { } }
+
+    it 'registers files to be watched' do
+      _, io_out = stub_open_wrapper!
+
+      fsevent.watch("/a/b/c.rb")
+      io_out.readline.chomp.should == "/a/b/c.rb"
+    end
+
+    it 'only registers a file with the wrapper script once' do
+      _, io_out = stub_open_wrapper!
+
+      files = ["a", "a", "b", "a", "b", "c", "d", "a"]
+      files.each { |f| fsevent.watch(f) }
+
+      files.uniq.each do |file|
+        io_out.readline.chomp.should == file
+      end
+    end
+
+    it 'passes changed files to a callback' do
+      io_in, io_out = stub_open_wrapper!
+
+      # to prove that very long filenames aren't truncated anywhere:
+      filename = SecureRandom.hex(4000) + ".rb"
+
+      results = []
+      fsevent = FSEvent.new { |f| results << f }
+
+      io_in.puts filename
+      fsevent.stub(realpaths_for_givenpath: [filename])
+      # test that the right socket is used, and it's ready for reading.
+      IO.select([fsevent.datasource])[0].should == [io_out]
+
+      Zeus.ui.should_receive(:info).with(%r{#{filename}})
+      fsevent.on_datasource_event
+      results[0].should == filename
+    end
+
+
+    it 'closes sockets not necessary in child processes' do
+      io_in, io_out = stub_open_wrapper!
+      fsevent.close_parent_socket
+
+      io_in.should be_closed
+      io_out.should be_closed
+    end
+
+    it 'integrates with the wrapper script to detect changes' do
+      results = []
+      callback = ->(path){ results << path }
+      fsevent = FSEvent.new(&callback)
+
+      file = Tempfile.new('fsevent-test')
+
+      fsevent.watch(file.path)
+
+      Zeus.ui.should_receive(:info).with(%r{#{file.path}})
+
+      FileUtils.touch(file.path)
+      IO.select([fsevent.datasource], [], [], 3)[0] # just wait for the data to appear
+      fsevent.on_datasource_event
+      results[0].should == file.path
+
+      file.unlink
+    end
+
+    private
+
+    def stub_open_wrapper!
+      io_in, io_out = Socket.pair(:UNIX, :STREAM)
+      FSEvent.any_instance.stub(open_wrapper: [io_in, io_out])
+
+      [io_in, io_out]
+    end
+
+  end
+end

data/spec/server/process_tree_monitor_spec.rb

@@ -0,0 +1,50 @@
+require 'zeus'
+
+class Zeus::Server
+  describe ProcessTreeMonitor do
+
+    let(:file_monitor) { stub }
+    let(:tree) { stub }
+    let(:monitor) { ProcessTreeMonitor.new(file_monitor, tree) }
+
+    it "closes sockets not useful to forked processes" do
+      parent, child = stub, stub
+      ProcessTreeMonitor.any_instance.stub(open_socketpair: [parent, child])
+      parent.should_receive(:close)
+      monitor.close_parent_socket
+    end
+
+    it "closes sockets not useful to the master process" do
+      parent, child = stub, stub
+      ProcessTreeMonitor.any_instance.stub(open_socketpair: [parent, child])
+      child.should_receive(:close)
+      monitor.close_child_socket
+    end
+
+    it "kills nodes with a feature that changed" do
+      tree.should_receive(:kill_nodes_with_feature).with("rails")
+      monitor.kill_nodes_with_feature("rails")
+    end
+
+    it "passes process inheritance information to the tree" do
+      IO.select([monitor.datasource], [], [], 0).should be_nil
+      monitor.__CHILD__pid_has_ppid(1, 2)
+      IO.select([monitor.datasource], [], [], 0.5).should_not be_nil
+      tree.should_receive(:process_has_parent).with(1, 2)
+      monitor.on_datasource_event
+    end
+
+    it "passes process feature information to the tree" do
+      IO.select([monitor.datasource], [], [], 0).should be_nil
+      monitor.__CHILD__pid_has_feature(1, "rails")
+      IO.select([monitor.datasource], [], [], 0.5).should_not be_nil
+      tree.should_receive(:process_has_feature).with(1, "rails")
+      file_monitor.should_receive(:watch).with("rails")
+      monitor.on_datasource_event
+    end
+
+    private
+
+  end
+end
+

data/spec/server/process_tree_spec.rb

@@ -0,0 +1,65 @@
+require 'zeus'
+
+class Zeus::Server
+
+  describe ProcessTree do
+
+    ROOT_PID = Process.pid
+    CHILD_1 = ROOT_PID + 1
+    CHILD_2 = ROOT_PID + 2
+    GRANDCHILD_1 = ROOT_PID + 3
+    GRANDCHILD_2 = ROOT_PID + 4
+
+    let(:process_tree) { ProcessTree.new }
+
+    before do
+      build_tree
+      add_features
+    end
+
+    it "doesn't kill the root node" do
+      Zeus.ui.should_receive(:error).with(/not killing zeus/i)
+      Process.should_not_receive(:kill)
+      process_tree.kill_nodes_with_feature("zeus")
+    end
+
+    it "kills a node that has a feature" do
+      expect_kill(CHILD_2)
+      process_tree.kill_nodes_with_feature("rails")
+    end
+
+    it "kills multiple nodes at the same level with a feature" do
+      expect_kill(GRANDCHILD_1)
+      expect_kill(GRANDCHILD_2)
+      process_tree.kill_nodes_with_feature("model")
+    end
+
+    private
+
+    def expect_kill(pid)
+      Process.should_receive(:kill).with("INT", pid)
+    end
+
+    def build_tree
+      process_tree.process_has_parent(CHILD_1, ROOT_PID)
+      process_tree.process_has_parent(CHILD_2, CHILD_1)
+      process_tree.process_has_parent(GRANDCHILD_1, CHILD_2)
+      process_tree.process_has_parent(GRANDCHILD_2, CHILD_2)
+    end
+
+    def add_features
+      [CHILD_2, GRANDCHILD_1, GRANDCHILD_2].each do |pid|
+        process_tree.process_has_feature(pid, "rails")
+      end
+
+      process_tree.process_has_feature(GRANDCHILD_1, "model")
+      process_tree.process_has_feature(GRANDCHILD_2, "model")
+
+      [ROOT_PID, CHILD_1, CHILD_2, GRANDCHILD_1, GRANDCHILD_2].each do |pid|
+        process_tree.process_has_feature(pid, "zeus")
+      end
+    end
+
+  end
+
+end

data/spec/ui_spec.rb

@@ -0,0 +1,54 @@
+require 'zeus'
+
+module Zeus
+  describe UI do
+
+    let(:ui) {
+      ui = UI.new
+      # override this method to return the result rather than printing it.
+      def ui.tell_me(msg, color)
+        return make_message(msg, color)
+      end
+      ui
+    }
+
+    it "prints errors in red, regardless of verbosity level" do
+      ui.error("error").should == "\x1b[31merror\x1b[0m\n"
+      ui.be_quiet!
+      ui.error("error").should == "\x1b[31merror\x1b[0m\n"
+    end
+
+    it "prints warnings in yellow, regardless of verbosity level" do
+      ui.warn("warning").should == "\x1b[33mwarning\x1b[0m\n"
+      ui.be_quiet!
+      ui.warn("warning").should == "\x1b[33mwarning\x1b[0m\n"
+    end
+
+    it "prints info messages in magenta, but not if quiet-mode is set" do
+      ui.info("info").should == "\x1b[35minfo\x1b[0m\n"
+      ui.be_quiet!
+      ui.info("info").should == nil
+    end
+
+    it "doesn't print debug messages by default" do
+      ui.debug("debug").should == nil
+    end
+
+    it "prints debug messages if debug-mode is set" do
+      ui.debug!
+      ui.debug("debug").should == "debug\n"
+    end
+
+    it "sets debug if ENV['DEBUG']" do
+      ENV['DEBUG'] = "yup"
+      ui.debug?.should be_true
+    end
+
+    it "doesn't print debug messages if both quiet-mode and debug-mode are set" do
+      ui.be_quiet!
+      ui.debug!
+      ui.debug("debug").should == nil
+    end
+
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zeus
 version: !ruby/object:Gem::Version
-  version: 0.2.6
+  version: 0.3.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-08-03 00:00:00.000000000 Z
+date: 2012-08-08 00:00:00.000000000 Z
 dependencies: []
 description: Zeus preloads pretty much everything you'll ever want to use in development.
 email:
@@ -20,11 +20,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .zeus.rb
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
-- TODO.md
 - bin/zeus
 - ext/fsevents-wrapper/fsevents-wrapper
 - ext/fsevents-wrapper/main.m
@@ -47,6 +47,11 @@ files:
 - lib/zeus/templates/rails.rb
 - lib/zeus/ui.rb
 - lib/zeus/version.rb
+- spec/cli_spec.rb
+- spec/server/file_monitor/fsevent_spec.rb
+- spec/server/process_tree_monitor_spec.rb
+- spec/server/process_tree_spec.rb
+- spec/ui_spec.rb
 - zeus.gemspec
 homepage: http://github.com/burke/zeus
 licenses: []
@@ -72,4 +77,10 @@ rubygems_version: 1.8.11
 signing_key: 
 specification_version: 3
 summary: Zeus is an alpha-quality application preloader with terrible documentation.
-test_files: []
+test_files:
+- spec/cli_spec.rb
+- spec/server/file_monitor/fsevent_spec.rb
+- spec/server/process_tree_monitor_spec.rb
+- spec/server/process_tree_spec.rb
+- spec/ui_spec.rb
+has_rdoc: 

data/TODO.md

@@ -1,14 +0,0 @@
-## TODO (roughly prioritized)
-
-* Make sure that when a command process's connection is dropped, it is killed
-* less leaky handling of at_exit pid killing
-* Refactor, refactor, refactor...
-* Support other frameworks?
-* Figure out how to run full test suites without multiple env loads
-
-## Ideas (not quite TODOs)
-
-* (maybe) Start the preloader as a daemon transparently when any command is run, then wait for it to finish
-* Support inotify on linux
-
-