spring 0.0.9 → 0.0.10

data/CHANGELOG.md

@@ -1,3 +1,30 @@
+## 0.0.10
+
+* Added `Spring.watch_via=` 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.
+* 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.
+* Don't preload `test_helper` or `spec_helper` by default. This was
+  causing people subtle problems (for example see #113) and is perhaps
+  surprising behaviour. It may be desirable but it depends on the
+  application, therefore we suggest it to people in the README but no
+  longer do it by default.
+* Don't stay connected to database in the application processes. There's
+  no need to keep a connection open.
+* Avoid using the database in the application processes. Previously,
+  reloading the autoloaded constants would inadvertantly cause a
+  connection to the database, which would then prevent tasks like
+  db:create from running (because at that point the database doesn't
+  exist)
+* Removed ability to specify list of files for a command to preload. We
+  weren't using this any more internally, and this is easy to do by
+  placing requires in suitable locations in the Rails boot process
+  (which is not explained in the README).
+* Seed the random number generator on each run.
+
 ## 0.0.9
 
 * Added `Spring::Commands::Rake.environment_matchers` for matching

data/Gemfile

@@ -4,5 +4,3 @@ source 'https://rubygems.org'
 gemspec
 
 gem 'listen', :require => false
-gem 'rb-inotify', :require => false
-gem 'rb-fsevent', :require => false

data/README.md

@@ -233,15 +233,20 @@ spring repository.
 
 ### `testunit`
 
-Runs a test (e.g. Test::Unit, MiniTest::Unit, etc.) Preloads the `test_helper` file.
+Runs a test (e.g. Test::Unit, MiniTest::Unit, etc.)
 
 This command can also recursively run a directory of tests. For example,
 `spring testunit test/functional` will run `test/functional/**/*_test.rb`.
 
+If your test helper file takes a while to load, consider preloading it
+(see "Running code before forking" below).
+
 ### `rspec`
 
-Runs an rspec spec, exactly the same as the `rspec` executable. Preloads
-the `spec_helper` file.
+Runs an rspec spec, exactly the same as the `rspec` executable.
+
+If your spec helper file takes a while to load, consider preloading it
+(see "Running code before forking" below).
 
 ### `cucumber`
 
@@ -268,11 +273,11 @@ a different sub command (e.g. `rails server`) then spring will automatically
 pass it through to the underlying `rails` executable (without the
 speed-up).
 
-## Configuration file
+## Configuration
 
 Spring will read `config/spring.rb` for custom settings, described below.
 
-### Specifying application root
+### Application root
 
 Spring must know how to find your Rails application. If you have a
 normal app everything works out of the box. If you are working on a
@@ -283,26 +288,20 @@ Spring where your app is located:
 Spring.application_root = './test/dummy'
 ```
 
-### Preloading files
-
-Every Spring command has the ability to preload a set of files. The
-`test` command for example preloads `test_helper` (it also adds the
-`test/` directory to your load path). If the
-defaults don't work for your application you can configure the
-preloads for every command:
-
-```ruby
-# if your test helper is called "helper"
-Spring::Commands::TestUnit.preloads = %w(helper)
+### Running code before forking
 
-# if you don't want to preload spec_helper.rb
-Spring::Commands::RSpec.preloads = []
+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
+which get run when your application initializers, such as
+`config/application.rb`, `config/environments/*.rb` or
+`config/initializers/*.rb`.
 
-# if you want to preload additional files for the console
-Spring::Commands::RailsConsole.preloads << 'extensions/console_helper'
-```
+For example, if loading your test helper is slow, you might like to
+preload it to speed up your test runs. To do this you could put a
+`require Rails.root.join("test/helper")` in
+`config/environments/test.rb`.
 
-### Callbacks after forking
+### Running code after forking
 
 You might want to run code after Spring forked off the process but
 before the actual command is run. You might want to use an
@@ -320,31 +319,27 @@ If you want to register multiple callbacks you can simply call
 
 ### Watching files and directories
 
-As mentioned above, Spring will automatically detect file changes to any file loaded when the server
-boots. If you would like to watch additional files or directories, use `watch`:
+Spring will automatically detect file changes to any file loaded when the server
+boots. Changes will cause the affected environments to be restarted.
+
+If there are additional files or directories which should trigger an
+application restart, you can specify them with `Spring.watch`:
 
 ```ruby
 Spring.watch "spec/factories"
 ```
 
-## Other configuration
-
-### tmp directory
-
-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.
-
-### Filesystem polling speed
-
-By default Spring will check the filesystem for changes once every 0.2 seconds. This
+By default Spring polls the filesystem for changes once every 0.2 seconds. This
 method requires zero configuration, but if you find that it's using too
-much CPU, then you can turn on event-based file system listening by
-adding the following to to your `Gemfile`:
+much CPU, then you can turn on event-based file system listening:
 
 ```ruby
-group :development, :test do
-  gem 'listen'
-end
+Spring.watch_method = :listen
 ```
 
-Note that this make the initial application startup slightly slower.
+You may need to add the [`listen` gem](https://github.com/guard/listen) to your `Gemfile`.
+
+### tmp directory
+
+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.

data/bin/spring

@@ -1,5 +1,9 @@
 #!/usr/bin/env ruby
 
-$LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
-require 'spring/client'
-Spring::Client.run(ARGV)
+if Process.respond_to?(:fork)
+  $LOAD_PATH.unshift File.expand_path("../../lib", __FILE__)
+  require 'spring/client'
+  Spring::Client.run(ARGV)
+else
+  exec "bundle", "exec", *ARGV
+end

data/lib/spring/application.rb

@@ -1,5 +1,4 @@
 require "set"
-require "json"
 
 require "spring/configuration"
 require "spring/watcher"
@@ -28,10 +27,17 @@ module Spring
         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
+
       require Spring.application_root_path.join("config", "environment")
 
+      ActiveRecord::Base.remove_connection if defined?(ActiveRecord::Base)
+
       watcher.add loaded_application_features
-      watcher.add "Gemfile", "Gemfile.lock"
+      watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
       watcher.add Rails.application.paths["config/initializers"]
 
       run
@@ -55,7 +61,7 @@ module Spring
       manager.puts
 
       streams = 3.times.map { client.recv_io }
-      args    = JSON.parse(client.read(client.gets.to_i))
+      args    = JSON.load(client.read(client.gets.to_i))
       command = Spring.command(args.shift)
 
       setup command
@@ -67,8 +73,23 @@ module Spring
         Process.setsid
         [STDOUT, STDERR, STDIN].zip(streams).each { |a, b| a.reopen(b) }
         IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+
+        ActiveRecord::Base.establish_connection if defined?(ActiveRecord::Base)
+        ARGV.replace(args)
+        srand
+
         invoke_after_fork_callbacks
-        command.call(args)
+
+        if command.respond_to?(:call)
+          command.call
+        else
+          exec_name = command.exec_name
+          gem_name  = command.gem_name if command.respond_to?(:gem_name)
+
+          exec = Gem.bin_path(gem_name || exec_name, exec_name)
+          $0 = exec
+          load exec
+        end
       }
 
       manager.puts pid

data/lib/spring/client.rb

@@ -1,9 +1,10 @@
 require "spring/configuration"
+require "spring/json"
+
 require "spring/client/command"
 require "spring/client/run"
 require "spring/client/help"
 require "spring/client/binstub"
-require "spring/client/start"
 require "spring/client/stop"
 require "spring/client/status"
 require "spring/client/rails"
@@ -13,7 +14,6 @@ module Spring
     COMMANDS = {
       "help"    => Client::Help,
       "binstub" => Client::Binstub,
-      "start"   => Client::Start,
       "stop"    => Client::Stop,
       "status"  => Client::Status,
       "rails"   => Client::Rails

data/lib/spring/client/help.rb

@@ -48,6 +48,8 @@ module Spring
       def description_for_command(command)
         if command.respond_to?(:description)
           command.description
+        elsif command.respond_to?(:exec_name)
+          "Runs the #{command.exec_name} command"
         else
           "No description given."
         end

data/lib/spring/client/run.rb

@@ -1,6 +1,5 @@
 require "rbconfig"
 require "socket"
-require "json"
 
 module Spring
   module Client
@@ -29,7 +28,10 @@ module Spring
 
       def boot_server
         env.socket_path.unlink if env.socket_path.exist?
-        Process.spawn(BINFILE, "start")
+        fork {
+          require "spring/server"
+          Spring::Server.boot
+        }
         sleep 0.1 until env.socket_path.exist?
       end
 
@@ -48,7 +50,7 @@ ERROR
 
       def connect_to_application(client)
         server.send_io client
-        send_json server, args: args, env: ENV.to_hash
+        send_json server, "args" => args, "default_rails_env" => default_rails_env
         server.gets or raise CommandNotFound
       end
 
@@ -95,9 +97,13 @@ ERROR
       def send_json(socket, data)
         data = JSON.dump(data)
 
-        socket.puts  data.length
+        socket.puts  data.bytesize
         socket.write data
       end
+
+      def default_rails_env
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
     end
   end
 end

data/lib/spring/commands.rb

@@ -1,9 +1,5 @@
 require "spring/watcher"
 
-# If the config/spring.rb contains requires for commands from other gems,
-# then we need to be under bundler.
-require "bundler/setup"
-
 module Spring
   @commands = {}
 
@@ -23,218 +19,15 @@ module Spring
     commands.fetch name
   end
 
-  module Commands
-    class Command
-      @preloads = []
-
-      def self.preloads
-        @preloads ||= superclass.preloads.dup
-      end
-
-      def self.preloads=(val)
-        @preloads = val
-      end
-
-      def preloads
-        self.class.preloads
-      end
-
-      def setup
-        preload_files
-      end
-
-      private
-
-      def preload_files
-        preloads.each do |file|
-          begin
-            require file
-          rescue LoadError => e
-            $stderr.puts <<-MESSAGE
-The #{self.class} command tried to preload #{file} but could not find it.
-You can configure what to preload in your `config/spring.rb` with:
-  #{self.class}.preloads = %w(files to preload)
-MESSAGE
-          end
-        end
-      end
-    end
-
-    class TestUnit < Command
-      preloads << "test_helper"
-
-      def env(*)
-        "test"
-      end
-
-      def setup
-        $LOAD_PATH.unshift "test"
-        super
-      end
-
-      def call(args)
-        if args.empty?
-          args = ['test']
-        end
-
-        ARGV.replace args
-        args.each do |arg|
-          path = File.expand_path(arg)
-          if File.directory?(path)
-            Dir[File.join path, "**", "*_test.rb"].each { |f| require f }
-          else
-            require path
-          end
-        end
-      end
-
-      def description
-        "Execute a Test::Unit test."
-      end
-    end
-    Spring.register_command "testunit", TestUnit.new
-
-    class RSpec < Command
-      preloads << "spec_helper"
-
-      def env(*)
-        "test"
-      end
-
-      def setup
-        $LOAD_PATH.unshift "spec"
-        require 'rspec/core'
-        ::RSpec::Core::Runner.disable_autorun!
-        super
-      end
-
-      def call(args)
-        $0 = "rspec"
-        Kernel.exit ::RSpec::Core::Runner.run(args)
-      end
-
-      def description
-        "Execute an RSpec spec."
-      end
-    end
-    Spring.register_command "rspec", RSpec.new
-
-    class Cucumber < Command
-      def env(*)
-        "test"
-      end
+  require "spring/commands/rails"
+  require "spring/commands/rake"
+  require "spring/commands/testunit"
+  require "spring/commands/rspec"
+  require "spring/commands/cucumber"
 
-      def setup
-        super
-        require 'cucumber'
-      end
-
-      def call(args)
-        # Cucumber's execute funtion returns `true` if any of the steps failed or
-        # some other error occured.
-        Kernel.exit(1) if ::Cucumber::Cli::Main.execute(args)
-      end
-
-      def description
-        "Execute a Cucumber feature."
-      end
-    end
-    Spring.register_command "cucumber", Cucumber.new
-
-    class Rake < Command
-      class << self
-        attr_accessor :environment_matchers
-      end
-
-      self.environment_matchers = {
-        /^(test|spec|cucumber)($|:)/ => "test"
-      }
-
-      def env(args)
-        self.class.environment_matchers.each do |matcher, environment|
-          return environment if matcher === args.first
-        end
-        nil
-      end
-
-      def setup
-        super
-        require "rake"
-      end
-
-      def call(args)
-        ARGV.replace args
-        ::Rake.application.run
-      end
-
-      def description
-        "Run a rake task."
-      end
-    end
-    Spring.register_command "rake", Rake.new
-
-    class RailsConsole < Command
-      def env(args)
-        args.first if args.first && !args.first.index("-")
-      end
-
-      def setup
-        require "rails/commands/console"
-      end
-
-      def call(args)
-        ARGV.replace args
-        ::Rails::Console.start(::Rails.application)
-      end
-
-      def description
-        nil
-      end
-    end
-    Spring.register_command "rails_console", RailsConsole.new
-
-    class RailsGenerate < Command
-      def setup
-        super
-        Rails.application.load_generators
-      end
-
-      def call(args)
-        ARGV.replace args
-        require "rails/commands/generate"
-      end
-
-      def description
-        nil
-      end
-    end
-    Spring.register_command "rails_generate", RailsGenerate.new
-
-    class RailsRunner < Command
-      def env(tail)
-        previous_option = nil
-        tail.reverse.each do |option|
-          case option
-          when /--environment=(\w+)/ then return $1
-          when '-e' then return previous_option
-          end
-          previous_option = option
-        end
-        nil
-      end
-
-      def call(args)
-        Object.const_set(:APP_PATH, Rails.root.join('config/application'))
-        ARGV.replace args
-        require "rails/commands/runner"
-      end
-
-      def description
-        nil
-      end
-    end
-    Spring.register_command "rails_runner", RailsRunner.new
-  end
+  # If the config/spring.rb contains requires for commands from other gems,
+  # then we need to be under bundler.
+  require "bundler/setup"
 
   # Load custom commands, if any.
   # needs to be at the end to allow modification of existing commands.