spring 0.0.5 → 0.0.6

data/lib/spring/client/command.rb

@@ -0,0 +1,18 @@
+require "spring/env"
+
+module Spring
+  module Client
+    class Command
+      def self.call(args)
+        new(args).call
+      end
+
+      attr_reader :args, :env
+
+      def initialize(args)
+        @args = args
+        @env  = Env.new
+      end
+    end
+  end
+end

data/lib/spring/client/help.rb

@@ -0,0 +1,23 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Help < Command
+      def call
+        puts <<-EOT
+Usage: spring COMMAND [ARGS]
+
+The most common spring commands are:
+ rake        Run a rake task
+ console     Start the Rails console
+ runner      Execute a command with the Rails runner
+ generate    Trigger a Rails generator
+
+ test        Execute a Test::Unit test
+ rspec       Execute an RSpec spec
+ cucumber    Execute a Cucumber feature
+EOT
+      end
+    end
+  end
+end

data/lib/spring/client/run.rb

@@ -0,0 +1,101 @@
+require "rbconfig"
+require "socket"
+
+require "spring/commands"
+
+module Spring
+  module Client
+    class Run < Command
+      SERVER_COMMAND = [
+        File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME')),
+        "-I", File.expand_path("../../..", __FILE__),
+        "-r", "spring/server",
+        "-r", "bundler/setup",
+        "-e", "Spring::Server.boot"
+      ]
+
+      FORWARDED_SIGNALS = %w(INT QUIT USR1 USR2 INFO)
+
+      def call
+        Spring.verify_environment!
+        boot_server unless env.server_running?
+
+        application, client = UNIXSocket.pair
+
+        server = UNIXSocket.open(env.socket_name)
+
+        verify_server_version(server)
+        server.send_io client
+        server.puts rails_env_for(args.first)
+
+        application.send_io STDOUT
+        application.send_io STDERR
+        application.send_io STDIN
+
+        application.puts args.length
+
+        args.each do |arg|
+          application.puts  arg.length
+          application.write arg
+        end
+
+        pid = server.gets.chomp
+
+        # We must not close the client socket until we are sure that the application has
+        # received the FD. Otherwise the FD can end up getting closed while it's in the server
+        # socket buffer on OS X. This doesn't happen on Linux.
+        client.close
+
+        if pid.empty?
+          exit 1
+        else
+          forward_signals(pid.to_i)
+          application.read # FIXME: receive exit status from server
+        end
+      rescue Errno::ECONNRESET
+        exit 1
+      ensure
+        application.close if application
+        server.close if server
+      end
+
+      # Boot the server into the process group of the current session.
+      # This will cause it to be automatically killed once the session
+      # ends (i.e. when the user closes their terminal).
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+        Process.spawn(*SERVER_COMMAND, pgroup: SID.pgid)
+        sleep 0.1 until env.socket_path.exist?
+      end
+
+      def verify_server_version(server)
+        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.
+You should restart the server and make sure to use the same version.
+
+CLIENT: #{env.version}, SERVER: #{server_version}
+ERROR
+          exit 1
+        end
+      end
+
+      def rails_env_for(command_name)
+        command = Spring.command(command_name)
+
+        if command.respond_to?(:env)
+          command.env
+        else
+          ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+        end
+      end
+
+      def forward_signals(pid)
+        (FORWARDED_SIGNALS & Signal.list.keys).each do |sig|
+          trap(sig) { Process.kill(sig, -Process.getpgid(pid)) }
+        end
+      end
+    end
+  end
+end

data/lib/spring/client/stop.rb

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Stop < Command
+      def call
+        Process.kill('SIGTERM', env.pid) if env.pid
+      end
+    end
+  end
+end

data/lib/spring/commands.rb

@@ -1,4 +1,6 @@
-class Spring
+require 'active_support/core_ext/class/attribute'
+
+module Spring
   @commands = {}
 
   class << self
@@ -13,56 +15,108 @@ class Spring
     end
   end
 
-  def self.command_registered?(name)
-    commands.has_key?(name)
+  def self.command?(name)
+    commands.include? name
   end
 
   def self.command(name)
     commands.fetch name
   end
 
-  # Load custom commands, if any
-  begin
-    require "./config/spring"
-  rescue LoadError
-  end
-
   module Commands
-    class Test
+    class Command
+      class_attribute :preloads
+      self.preloads = []
+
+      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 Test < Command
+      self.preloads += %w(test_helper)
+
       def env
         "test"
       end
 
       def setup
         $LOAD_PATH.unshift "test"
-        require "test_helper"
+        super
       end
 
       def call(args)
-        ARGV.replace args
-        require File.expand_path(args.first)
+        if args.size > 0
+          ARGV.replace args
+          path = File.expand_path(args.first)
+
+          if File.directory?(path)
+            Dir[File.join path, "**", "*_test.rb"].each { |f| require f }
+          else
+            require path
+          end
+        else
+          $stderr.puts "you need to specify what test to run: spring test TEST_NAME"
+        end
       end
     end
     Spring.register_command "test", Test.new
 
-    class RSpec
+    class RSpec < Command
+      self.preloads += %w(spec_helper)
+
       def env
         "test"
       end
 
       def setup
         $LOAD_PATH.unshift "spec"
-        require "spec_helper"
+        super
+        require 'rspec/core'
       end
 
       def call(args)
+        $0 = "rspec"
         ::RSpec::Core::Runner.run(args)
       end
     end
     Spring.register_command "rspec", RSpec.new
 
-    class Rake
+    class Cucumber < Command
+      def env
+        "test"
+      end
+
+      def setup
+        super
+        require 'cucumber'
+      end
+
+      def call(args)
+        ::Cucumber::Cli::Main.execute(args)
+      end
+    end
+    Spring.register_command "cucumber", Cucumber.new
+
+    class Rake < Command
       def setup
+        super
         require "rake"
       end
 
@@ -73,20 +127,22 @@ class Spring
     end
     Spring.register_command "rake", Rake.new
 
-    class Console
-      def setup
-        require "rails/commands/console"
-      end
 
+    class Console < Command
       def call(args)
+        # This cannot be preloaded as it messes up the IRB prompt on OS X
+        # for unknown reasons. See discussion in issue #34.
+        require "rails/commands/console"
+
         ARGV.replace args
         ::Rails::Console.start(::Rails.application)
       end
     end
     Spring.register_command "console", Console.new, alias: "c"
 
-    class Generate
+    class Generate < Command
       def setup
+        super
         Rails.application.load_generators
       end
 
@@ -97,7 +153,7 @@ class Spring
     end
     Spring.register_command "generate", Generate.new, alias: "g"
 
-    class Runner
+    class Runner < Command
       def call(args)
         Object.const_set(:APP_PATH, Rails.root.join('config/application'))
         ARGV.replace args
@@ -106,4 +162,10 @@ class Spring
     end
     Spring.register_command "runner", Runner.new, alias: "r"
   end
+
+  # Load custom commands, if any.
+  # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("./config/spring.rb")
+  require config if File.exist?(config)
+
 end

data/lib/spring/configuration.rb

@@ -0,0 +1,31 @@
+require "spring/errors"
+
+module Spring
+  class << self
+    attr_accessor :application_root
+
+    def verify_environment!
+      application_root_path
+    end
+
+    def application_root_path
+      @application_root_path ||= begin
+        path = Pathname.new(File.expand_path(application_root || find_project_root))
+        raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
+        path
+      end
+    end
+
+    private
+
+    def find_project_root(current_dir = Pathname.new(Dir.pwd))
+      if current_dir.join("Gemfile").exist?
+        current_dir
+      elsif current_dir.root?
+        raise UnknownProject.new(Dir.pwd)
+      else
+        find_project_root(current_dir.parent)
+      end
+    end
+  end
+end

data/lib/spring/env.rb

@@ -1,19 +1,25 @@
 require "pathname"
-require "spring/sid"
 require "fileutils"
 
-class Spring
+require "spring/version"
+require "spring/sid"
+
+module Spring
   IGNORE_SIGNALS = %w(INT QUIT)
 
   class Env
     attr_reader :root
 
-    def initialize
-      @root = Pathname.new(File.expand_path('.'))
+    def initialize(root = nil)
+      @root = root || Pathname.new(File.expand_path('.'))
+    end
+
+    def version
+      Spring::VERSION
     end
 
     def tmp_path
-      path = root.join('tmp/spring')
+      path = default_tmp_path
       FileUtils.mkdir_p(path) unless path.exist?
       path
     end
@@ -29,5 +35,37 @@ class Spring
     def pidfile_path
       tmp_path.join("#{SID.sid}.pid")
     end
+
+    def pid
+      pidfile_path.exist? ? pidfile_path.read.to_i : nil
+    end
+
+    def app_name
+      root.basename
+    end
+
+    def server_running?
+      if pidfile_path.exist?
+        pidfile = pidfile_path.open('r')
+        !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+      else
+        false
+      end
+    ensure
+      if pidfile
+        pidfile.flock(File::LOCK_UN)
+        pidfile.close
+      end
+    end
+
+    private
+
+    def default_tmp_path
+      if ENV['SPRING_TMP_PATH']
+        Pathname.new(ENV['SPRING_TMP_PATH'])
+      else
+        root.join('tmp/spring')
+      end
+    end
   end
 end

data/lib/spring/errors.rb

@@ -0,0 +1,33 @@
+module Spring
+  class ClientError < StandardError; end
+
+  class UnknownProject < ClientError
+    attr_reader :current_dir
+
+    def initialize(current_dir)
+      @current_dir = current_dir
+    end
+
+    def message
+      "Spring was unable to locate the root of your project. There was no Gemfile " \
+        "present in the current directory (#{current_dir}) or any of the parent " \
+        "directories."
+    end
+  end
+
+  class MissingApplication < ClientError
+    attr_reader :project_root
+
+    def initialize(project_root)
+      @project_root = project_root
+    end
+
+    def message
+      "Spring was unable to find your config/application.rb file. " \
+        "Your project root was detected at #{project_root}, so spring " \
+        "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
+        "configure the root of your application by setting Spring.application_root in " \
+        "config/spring.rb."
+    end
+  end
+end