spring 0.0.8 → 1.0.0

data/lib/spring/server.rb

@@ -1,8 +1,20 @@
+module Spring
+  class << self
+    attr_reader :original_env
+  end
+  @original_env = ENV.to_hash
+end
+
 require "socket"
+require "thread"
 
+require "spring/configuration"
 require "spring/env"
 require "spring/application_manager"
 require "spring/process_title_updater"
+require "spring/json"
+
+# Must be last, as it requires bundler/setup
 require "spring/commands"
 
 # readline must be required before we setpgid, otherwise the require may hang,
@@ -19,47 +31,64 @@ module Spring
 
     def initialize(env = Env.new)
       @env          = env
-      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(k) }
+      @applications = Hash.new { |h, k| h[k] = ApplicationManager.new(self, k) }
       @pidfile      = env.pidfile_path.open('a')
+      @mutex        = Mutex.new
+    end
+
+    def log(message)
+      env.log "[server] #{message}"
     end
 
     def boot
+      Spring.verify_environment
+
+      write_pidfile
       set_pgid
       ignore_signals
       set_exit_hook
-      write_pidfile
-      redirect_output
       set_process_title
+      watch_bundle
+      start_server
+    end
 
+    def start_server
       server = UNIXServer.open(env.socket_name)
+      log "started on #{env.socket_name}"
       loop { serve server.accept }
     end
 
     def serve(client)
+      log "accepted client"
       client.puts env.version
 
-      app_client       = client.recv_io
-      command          = JSON.parse(client.read(client.gets.to_i))
-      args, client_env = command.values_at('args', 'env')
+      app_client = client.recv_io
+      command    = JSON.load(client.read(client.gets.to_i))
+
+      args, default_rails_env = command.values_at('args', 'default_rails_env')
 
       if Spring.command?(args.first)
+        log "running command #{args.first}"
         client.puts
-        client.puts @applications[rails_env_for(args, client_env)].run(app_client)
+        client.puts @applications[rails_env_for(args, default_rails_env)].run(app_client)
       else
+        log "command not found #{args.first}"
         client.close
       end
     rescue SocketError => e
       raise e unless client.eof?
+    ensure
+      redirect_output
     end
 
-    def rails_env_for(args, client_env)
+    def rails_env_for(args, default_rails_env)
       command = Spring.command(args.first)
 
       if command.respond_to?(:env)
         env = command.env(args.drop(1))
       end
 
-      env || client_env['RAILS_ENV'] || client_env['RACK_ENV'] || 'development'
+      env || default_rails_env
     end
 
     # Boot the server into the process group of the current session.
@@ -78,14 +107,16 @@ module Spring
     def set_exit_hook
       server_pid = Process.pid
 
-      at_exit do
-        # We don't want this hook to run in any forks of the current process
-        if Process.pid == server_pid
-          [env.socket_path, env.pidfile_path].each do |path|
-            path.unlink if path.exist?
-          end
+      # We don't want this hook to run in any forks of the current process
+      at_exit { shutdown if Process.pid == server_pid }
+    end
+
+    def shutdown
+      @applications.values.each(&:stop)
 
-          @applications.values.each(&:stop)
+      [env.socket_path, env.pidfile_path].each do |path|
+        if path.exist?
+          path.unlink rescue nil
         end
       end
     end
@@ -96,24 +127,16 @@ module Spring
         @pidfile.write("#{Process.pid}\n")
         @pidfile.fsync
       else
-        $stderr.puts "#{@pidfile.path} is locked; it looks like a server is already running"
         exit 1
       end
     end
 
-    # We can't leave STDOUT, STDERR as they as because then they will
-    # never get closed for the lifetime of the server. This means that
-    # piping, e.g. "spring rake -T | grep db" won't work correctly
-    # because grep will hang while waiting for its stdin to reach EOF.
-    #
-    # However we do want server output to go to the terminal in case
-    # there are exceptions etc, so we just open the current terminal
-    # device directly.
+    # We need to redirect STDOUT and STDERR, otherwise the server will
+    # keep the original FDs open which would break piping. (e.g.
+    # `spring rake -T | grep db` would hang forever because the server
+    # would keep the stdout FD open.)
     def redirect_output
-      # ruby doesn't expose ttyname()
-      file = open(STDIN.tty? ? `tty`.chomp : "/dev/null", "a")
-      STDOUT.reopen(file)
-      STDERR.reopen(file)
+      [STDOUT, STDERR].each { |stream| stream.reopen(env.log_file) }
     end
 
     def set_process_title
@@ -121,5 +144,13 @@ module Spring
         "spring server | #{env.app_name} | started #{distance} ago"
       }
     end
+
+    def watch_bundle
+      @bundle_mtime = env.bundle_mtime
+    end
+
+    def application_starting
+      @mutex.synchronize { exit if env.bundle_mtime != @bundle_mtime }
+    end
   end
 end

data/lib/spring/version.rb

@@ -1,3 +1,3 @@
 module Spring
-  VERSION = "0.0.8"
+  VERSION = "1.0.0"
 end

data/lib/spring/watcher/abstract.rb

@@ -36,15 +36,19 @@ module Spring
           end
         end
 
-        items.each do |item|
-          if item.directory?
-            directories << item.realpath.to_s
-          else
-            files << item.realpath.to_s
+        items = items.select(&:exist?)
+
+        synchronize {
+          items.each do |item|
+            if item.directory?
+              directories << item.realpath.to_s
+            else
+              files << item.realpath.to_s
+            end
           end
-        end
 
-        subjects_changed
+          subjects_changed
+        }
       end
 
       def stale?

data/lib/spring/watcher/listen.rb

@@ -1,21 +1,18 @@
+gem "listen", "~> 1.0"
+require "listen"
+require "listen/version"
+
 module Spring
   module Watcher
     class Listen < Abstract
       attr_reader :listener
 
-      def self.available?
-        require "listen"
-        true
-      rescue LoadError
-        false
-      end
-
       def start
         unless @listener
-          @listener = ::Listen::MultiListener.new(*base_directories)
+          @listener = ::Listen.to(*base_directories, relative_paths: false)
           @listener.latency(latency)
           @listener.change(&method(:changed))
-          @listener.start(false)
+          @listener.start
         end
       end
 
@@ -45,9 +42,10 @@ module Spring
       end
 
       def base_directories
-        [root] +
+        ([root] +
           files.reject       { |f| f.start_with? root }.map { |f| File.expand_path("#{f}/..") } +
           directories.reject { |d| d.start_with? root }
+        ).uniq
       end
     end
   end

data/lib/spring/watcher/polling.rb

@@ -5,7 +5,7 @@ module Spring
 
       def initialize(root, latency)
         super
-        @mtime  = nil
+        @mtime  = 0
         @poller = nil
       end
 

data/lib/spring/watcher.rb

@@ -1,25 +1,31 @@
 require "spring/watcher/abstract"
-require "spring/watcher/listen"
-require "spring/watcher/polling"
+require "spring/configuration"
 
 module Spring
   class << self
     attr_accessor :watch_interval
     attr_writer :watcher
+    attr_reader :watch_method
+  end
+
+  def self.watch_method=(method)
+    case method
+    when :polling
+      require_relative "watcher/polling"
+      @watch_method = Watcher::Polling
+    when :listen
+      require_relative "watcher/listen"
+      @watch_method = Watcher::Listen
+    else
+      @watch_method = method
+    end
   end
 
   self.watch_interval = 0.2
+  self.watch_method = :polling
 
   def self.watcher
-    @watcher ||= watcher_class.new(Spring.application_root_path, watch_interval)
-  end
-
-  def self.watcher_class
-    if Watcher::Listen.available?
-      Watcher::Listen
-    else
-      Watcher::Polling
-    end
+    @watcher ||= watch_method.new(Spring.application_root_path, watch_interval)
   end
 
   def self.watch(*items)

data/spring.gemspec

@@ -11,6 +11,7 @@ Gem::Specification.new do |gem|
   gem.description   = %q{Rails application preloader}
   gem.summary       = %q{Rails application preloader}
   gem.homepage      = "http://github.com/jonleighton/spring"
+  gem.license       = "MIT"
 
   gem.files         = `git ls-files`.split($/)
   gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }