spring 0.0.10 → 0.0.11

data/.travis.yml

@@ -2,3 +2,6 @@ language: ruby
 rvm:
   - 1.9.3
   - 2.0.0
+env:
+  - RAILS_VERSION="~> 3.2.0"
+  - RAILS_VERSION="~> 4.0.0"

data/CHANGELOG.md

@@ -1,9 +1,20 @@
+## 0.0.11
+
+* Added the `rails destroy` command.
+* Global config file in `~/.spring.rb`
+* Added logging for debugging. Specify a log file with the
+  `SPRING_LOG` environment variable.
+* Fix hang on "Run `bundle install` to install missing gems"
+* Added hack to make backtraces generated when running a command
+  quieter (by stripping out all of the lines relating to spring)
+* Rails 4 is officially supported
+
 ## 0.0.10
 
-* Added `Spring.watch_via=` configuration option to switch between
+* Added `Spring.watch_method=` configuration option to switch between
   polling and the `listen` gem. Previously, we used the `listen` gem if
   it was available, but this makes the option explicit. Set
-  `Spring.watch_via = :listen` to use the listen gem.
+  `Spring.watch_method = :listen` to use the listen gem.
 * Fallback when Process.fork is not available. In such cases, the user
   will not receive the speedup that Spring provides, but won't receive
   an error either.

data/Gemfile

@@ -3,4 +3,4 @@ source 'https://rubygems.org'
 # Specify your gem's dependencies in spring.gemspec
 gemspec
 
-gem 'listen', :require => false
+gem 'listen', "~> 1.0", :require => false

data/README.md

@@ -7,13 +7,6 @@ problem as [spork](https://github.com/sporkrb/spork),
 [zeus](https://github.com/burke/zeus) and
 [commands](https://github.com/rails/commands).
 
-I made it because we are having a discussion on the rails core team
-about shipping something to solve this problem with rails. So this is my
-proposal, as working code.
-
-(At least I hope it's working code, but this is alpha software at the
-moment. Please do try it and let me know if you hit problems.)
-
 ## Features
 
 Spring is most similar to Zeus, but it's implemented in pure Ruby, and
@@ -48,6 +41,7 @@ Ruby versions supported:
 Rails versions supported:
 
 * 3.2
+* 4.0
 
 Spring makes extensive use of `Process#fork`, so won't be able to run on
 any platform which doesn't support that (Windows, JRuby).
@@ -158,7 +152,7 @@ Note: Don't use spring binstubs with `bundle install --binstubs`.  If
 you do this, spring and bundler will overwrite each other. If _you will_
 not be using a command with spring, use `bundle binstub [GEM]` to
 generate a bundler binstub for that specific gem.  If you _will_ be
-using a command with spring, generate a spring binstub _instaed of_ a
+using a command with spring, generate a spring binstub _instead of_ a
 bundler binstub; spring will run your command inside the bundle anyway.
 
 If we edit any of the application files, or test files, the change will
@@ -222,7 +216,7 @@ Spring stopped.
 
 The following commands are shipped by default.
 
-Custom commands can be specified in `config/spring.rb`. See
+Custom commands can be specified in the Spring config file. See
 [`lib/spring/commands.rb`](https://github.com/jonleighton/spring/blob/master/lib/spring/commands.rb)
 for examples.
 
@@ -275,7 +269,7 @@ speed-up).
 
 ## Configuration
 
-Spring will read `config/spring.rb` for custom settings, described below.
+Spring will read `~/.spring.rb` and `config/spring.rb` for custom settings, described below.
 
 ### Application root
 
@@ -291,7 +285,7 @@ Spring.application_root = './test/dummy'
 ### Running code before forking
 
 There is no `Spring.before_fork` callback. To run something before the
-fork, you can place it in `config/spring.rb` or in any of the files
+fork, you can place it in `~/.spring.rb` or `config/spring.rb` or in any of the files
 which get run when your application initializers, such as
 `config/application.rb`, `config/environments/*.rb` or
 `config/initializers/*.rb`.
@@ -343,3 +337,14 @@ You may need to add the [`listen` gem](https://github.com/guard/listen) to your
 
 Spring needs a tmp directory. This will default to `Rails.root.join('tmp', 'spring')`.
 You can set your own configuration directory by setting the `SPRING_TMP_PATH` environment variable.
+
+## Troubleshooting
+
+If you want to get more information about what spring is doing, you can
+specify a log file with the `SPRING_LOG` environment variable:
+
+```
+spring stop # if spring is already running
+export SPRING_LOG=/tmp/spring.log
+spring rake -T
+```

data/lib/spring/application.rb

@@ -1,69 +1,107 @@
 require "set"
-
-require "spring/configuration"
 require "spring/watcher"
+require "thread"
 
 module Spring
   class Application
-    attr_reader :manager, :watcher
+    attr_reader :manager, :watcher, :spring_env
 
     def initialize(manager, watcher = Spring.watcher)
-      @manager = manager
-      @watcher = watcher
-      @setup   = Set.new
+      @manager    = manager
+      @watcher    = watcher
+      @setup      = Set.new
+      @spring_env = Env.new
+      @preloaded  = false
+      @mutex      = Mutex.new
+      @waiting    = 0
+      @exiting    = false
 
       # Workaround for GC bug in Ruby 2 which causes segfaults if watcher.to_io
       # instances get dereffed.
       @fds = [manager, watcher.to_io]
     end
 
-    def start
+    def log(message)
+      spring_env.log "[application:#{ENV['RAILS_ENV']}] #{message}"
+    end
+
+    def preloaded?
+      @preloaded
+    end
+
+    def exiting?
+      @exiting
+    end
+
+    def preload
+      log "preloading app"
+
       require Spring.application_root_path.join("config", "application")
 
-      # The test environment has config.cache_classes = true set by default.
-      # However, we don't want this to prevent us from performing class reloading,
-      # so this gets around that.
-      ::Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
+      # config/environments/test.rb will have config.cache_classes = true. However
+      # we want it to be false so that we can reload files. This is a hack to
+      # override the effect of config.cache_classes = true. We can then actually
+      # set config.cache_classes = false after loading the environment.
+      Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
         ActiveSupport::Dependencies.mechanism = :load
       end
 
-      # This initializer has issues after we disconnect from the DB, but we don't need it.
-      if defined?(ActiveRecord::Base)
-        ActiveRecord::Railtie.initializers.delete_if { |i| i.name == "active_record.set_reloader_hooks" }
-      end
+      # Ensure eager loading does not take place, even though it usually would do
+      # in test mode with config.cache_classes = true. Eager loading in this situation
+      # just makes the initial run take longer without much gain in subsequent runs,
+      # at least in my testing.
+      Rails::Application::Finisher.initializers.delete_if { |i| i.name == :eager_load! }
 
       require Spring.application_root_path.join("config", "environment")
 
-      ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+      Rails.application.config.cache_classes = false
+      disconnect_database
 
       watcher.add loaded_application_features
       watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
       watcher.add Rails.application.paths["config/initializers"]
 
-      run
+      @preloaded = true
     end
 
     def run
+      log "running"
       watcher.start
 
       loop do
         IO.select(@fds)
 
         if watcher.stale?
-          exit
+          log "watcher stale; exiting"
+          manager.close
+          @exiting = true
+          try_exit
+          sleep
         else
           serve manager.recv_io(UNIXSocket)
         end
       end
     end
 
+    def try_exit
+      @mutex.synchronize {
+        exit if exiting? && @waiting == 0
+      }
+    end
+
     def serve(client)
+      log "got client"
       manager.puts
 
       streams = 3.times.map { client.recv_io }
+      [STDOUT, STDERR].zip(streams).each { |a, b| a.reopen(b) }
+
+      preload unless preloaded?
+
       args    = JSON.load(client.read(client.gets.to_i))
       command = Spring.command(args.shift)
 
+      connect_database
       setup command
 
       ActionDispatch::Reloader.cleanup!
@@ -71,14 +109,15 @@ module Spring
 
       pid = fork {
         Process.setsid
-        [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
+        STDIN.reopen(streams.last)
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
 
-        ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+        connect_database
         ARGV.replace(args)
         srand
 
         invoke_after_fork_callbacks
+        shush_backtraces
 
         if command.respond_to?(:call)
           command.call
@@ -92,17 +131,29 @@ module Spring
         end
       }
 
+      disconnect_database
+      [STDOUT, STDERR].each { |stream| stream.reopen(spring_env.log_file) }
+
+      log "forked #{pid}"
       manager.puts pid
 
       # Wait in a separate thread so we can run multiple commands at once
       Thread.new {
+        @mutex.synchronize { @waiting += 1 }
+
         _, status = Process.wait2 pid
+        log "#{pid} exited with #{status.exitstatus}"
+
         streams.each(&:close)
         client.puts(status.exitstatus)
         client.close
+
+        @mutex.synchronize { @waiting -= 1 }
+        try_exit
       }
 
     rescue => e
+      log "exception: #{e}"
       streams.each(&:close) if streams
       client.puts(1)
       client.close
@@ -131,5 +182,31 @@ module Spring
     def loaded_application_features
       $LOADED_FEATURES.select { |f| f.start_with?(File.realpath(Rails.root)) }
     end
+
+    def disconnect_database
+      ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+    end
+
+    def connect_database
+      ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+    end
+
+    # This feels very naughty
+    def shush_backtraces
+      Kernel.module_eval do
+        old_raise = Kernel.method(:raise)
+        remove_method :raise
+        define_method :raise do |*args|
+          begin
+            old_raise.call(*args)
+          ensure
+            if $!
+              lib = File.expand_path("..", __FILE__)
+              $!.backtrace.reject! { |line| line.start_with?(lib) }
+            end
+          end
+        end
+      end
+    end
   end
 end

data/lib/spring/application_manager.rb

@@ -13,6 +13,10 @@ module Spring
       @mutex      = Mutex.new
     end
 
+    def log(message)
+      server.log(message)
+    end
+
     # We're not using @mutex.synchronize to avoid the weird "<internal:prelude>:10"
     # line which messes with backtraces in e.g. rspec
     def synchronize
@@ -28,9 +32,6 @@ module Spring
     end
 
     def restart
-      # Restarting is a background operation. If it fails, we don't want
-      # any terminal output. The user will see the output when they next
-      # try to run a command.
       start_child(true)
     end
 
@@ -46,10 +47,12 @@ module Spring
           rescue Errno::ECONNRESET, Errno::EPIPE
             # The child has died but has not been collected by the wait thread yet,
             # so start a new child and try again.
+            log "child dead; starting"
             start
             yield
           end
         else
+          log "child not running; starting"
           start
           yield
         end
@@ -63,8 +66,12 @@ module Spring
         child.gets
       end
 
-      child.gets.chomp.to_i # get the pid
-    rescue Errno::ECONNRESET, Errno::EPIPE
+      pid = child.gets
+      pid = pid.chomp.to_i if pid
+      log "got worker pid #{pid}"
+      pid
+    rescue Errno::ECONNRESET, Errno::EPIPE => e
+      log "#{e} while reading from child; returning no pid"
       nil
     ensure
       client.close
@@ -76,13 +83,11 @@ module Spring
 
     private
 
-    def start_child(silence = false)
+    def start_child(preload = false)
       server.application_starting
 
       @child, child_socket = UNIXSocket.pair
       @pid = fork {
-        [STDOUT, STDERR].each { |s| s.reopen('/dev/null', 'w') } if silence
-
         (ObjectSpace.each_object(IO).to_a - [STDOUT, STDERR, STDIN, child_socket])
           .reject(&:closed?)
           .each(&:close)
@@ -93,7 +98,9 @@ module Spring
           "spring app    | #{spring_env.app_name} | started #{distance} ago | #{app_env} mode"
         }
 
-        Application.new(child_socket).start
+        app = Application.new(child_socket)
+        app.preload if preload
+        app.run
       }
       child_socket.close
     end

data/lib/spring/client.rb

@@ -1,4 +1,4 @@
-require "spring/configuration"
+require "spring/errors"
 require "spring/json"
 
 require "spring/client/command"

data/lib/spring/client/binstub.rb

@@ -47,7 +47,7 @@ module Spring
 # https://github.com/rubygems/rubygems/pull/435
 
 glob       = "{#{Gem::Specification.dirs.join(",")}}/spring-*.gemspec"
-candidates = Dir[glob].to_a.sort
+candidates = Dir[glob].to_a.sort_by { |c| Gem::Version.new(File.basename(c).split(/[-\.]/)[1...-1].join(".")) }
 
 spec = Gem::Specification.load(candidates.last)
 

data/lib/spring/client/rails.rb

@@ -3,12 +3,13 @@ require "set"
 module Spring
   module Client
     class Rails < Command
-      COMMANDS = Set.new %w(console runner generate)
+      COMMANDS = Set.new %w(console runner generate destroy)
 
       ALIASES = {
         "c" => "console",
         "r" => "runner",
-        "g" => "generate"
+        "g" => "generate",
+        "d" => "destroy"
       }
 
       def self.description
@@ -21,7 +22,11 @@ module Spring
         if COMMANDS.include?(command_name)
           Run.call(["rails_#{command_name}", *args.drop(2)])
         else
-          exec "bundle", "exec", *args
+          require "spring/configuration"
+          ARGV.shift
+          Object.const_set(:APP_PATH, Spring.application_root_path.join("config/application").to_s)
+          require Spring.application_root_path.join("config/boot")
+          require "rails/commands"
         end
       end
     end

data/lib/spring/client/run.rb

@@ -6,13 +6,15 @@ module Spring
     class Run < Command
       FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO) & Signal.list.keys
 
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
       def server
         @server ||= UNIXSocket.open(env.socket_name)
       end
 
       def call
-        Spring.verify_environment!
-
         boot_server unless env.server_running?
         verify_server_version
 
@@ -28,18 +30,24 @@ module Spring
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
-        fork {
+
+        pid = fork {
           require "spring/server"
           Spring::Server.boot
         }
-        sleep 0.1 until env.socket_path.exist?
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+          exit status.exitstatus if status
+          sleep 0.1
+        end
       end
 
       def verify_server_version
         server_version = server.gets.chomp
         if server_version != env.version
           $stderr.puts <<-ERROR
-There is a version mismatch beween the spring client and the server.
+There is a version mismatch between the spring client and the server.
 You should restart the server and make sure to use the same version.
 
 CLIENT: #{env.version}, SERVER: #{server_version}
@@ -55,6 +63,8 @@ ERROR
       end
 
       def run_command(client, application)
+        log "sending command"
+
         application.send_io STDOUT
         application.send_io STDERR
         application.send_io STDIN
@@ -70,9 +80,16 @@ ERROR
         client.close
 
         if pid && !pid.empty?
+          log "got pid: #{pid}"
+
           forward_signals(pid.to_i)
-          exit application.read.to_i
+          status = application.read.to_i
+
+          log "got exit status #{status}"
+
+          exit status
         else
+          log "got no pid"
           exit 1
         end
       ensure