spring 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in spring.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2012 Jon Leighton
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,29 @@
+# Spring
+
+TODO: Write a gem description
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'spring'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install spring
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new do |t|
+  t.libs << "test"
+  t.test_files = FileList["test/{acceptance,unit}/*_test.rb"]
+  t.verbose = true
+end
+
+task default: :test

data/bin/spring

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+$LOAD_PATH.unshift File.expand_path('../../lib', __FILE__)
+require 'spring'
+Spring.run(ARGV)

data/lib/spring.rb

@@ -0,0 +1,98 @@
+require "rbconfig"
+require "socket"
+require "pty"
+require "io/console"
+
+require "spring/version"
+require "spring/sid"
+require "spring/env"
+require "spring/commands"
+
+class Spring
+  SERVER_COMMAND = [
+    File.join(*RbConfig::CONFIG.values_at('bindir', 'RUBY_INSTALL_NAME')),
+    "-r", "bundler/setup",
+    File.expand_path("../spring/server.rb", __FILE__)
+  ]
+
+  def self.run(args)
+    exit new.run(args)
+  end
+
+  attr_reader :env
+
+  def initialize
+    @env = Env.new
+  end
+
+  def server_running?
+    env.socket_path.exist?
+  end
+
+  def boot_server
+    # 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).
+    Process.spawn(*SERVER_COMMAND, pgroup: SID.pgid)
+    sleep 0.1 until server_running?
+  end
+
+  def run(args)
+    boot_server unless server_running?
+
+    socket = UNIXSocket.open(env.socket_name)
+    socket.write rails_env_for(args.first)
+    socket.close
+
+    socket = UNIXSocket.open(env.socket_name)
+
+    socket.send_io STDOUT
+    socket.send_io STDERR
+    socket.send_io stdin_slave
+
+    socket.puts args.length
+
+    args.each do |arg|
+      socket.puts  arg.length
+      socket.write arg
+    end
+
+    # FIXME: receive exit status from server
+    socket.read
+    true
+  rescue Errno::ECONNRESET
+    false
+  ensure
+    socket.close
+  end
+
+  private
+
+  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
+
+  # FIXME: need to make special chars (e.g. arrow keys) work
+  def stdin_slave
+    master, slave = PTY.open
+    master.raw!
+
+    Thread.new {
+      until STDIN.closed?
+        # This makes special chars work, but has some weird side-effects that
+        # I need to figure out.
+        # master.write STDIN.getch
+
+        master.write STDIN.read(1)
+      end
+    }
+
+    slave
+  end
+end

data/lib/spring/application.rb

@@ -0,0 +1,109 @@
+require "spring/application_watcher"
+require "spring/commands"
+require "set"
+
+class Spring
+  class << self
+    attr_accessor :application_watcher
+  end
+
+  self.application_watcher = ApplicationWatcher.new
+
+  class Application
+    WATCH_INTERVAL = 0.2
+
+    attr_reader :manager, :watcher
+
+    def initialize(manager, watcher = Spring.application_watcher)
+      @manager = manager
+      @watcher = watcher
+      @setup   = Set.new
+
+      @stdout = IO.new(STDOUT.fileno)
+      @stderr = IO.new(STDERR.fileno)
+      @stdin  = IO.new(STDIN.fileno)
+    end
+
+    def start
+      require "./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
+        ActiveSupport::Dependencies.mechanism = :load
+      end
+
+      require "./config/environment"
+
+      watcher.add_files $LOADED_FEATURES
+      watcher.add_files ["Gemfile", "Gemfile.lock"].map { |f| "#{Rails.root}/#{f}" }
+      watcher.add_globs Rails.application.paths["config/initializers"].map { |p| "#{Rails.root}/#{p}/*.rb" }
+
+      run
+    end
+
+    def run
+      loop do
+        watch_application
+
+        client = manager.recv_io
+        client.autoclose = false # prevent GC closing the FD
+
+        serve UNIXSocket.for_fd(client.fileno)
+      end
+    end
+
+    def watch_application
+      until IO.select([manager], [], [], WATCH_INTERVAL)
+        exit if watcher.stale?
+      end
+    end
+
+    def serve(client)
+      redirect_output(client) do
+        args_length = client.gets.to_i
+        args        = args_length.times.map { client.read(client.gets.to_i) }
+        command     = Spring.command(args.shift)
+
+        setup command
+
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+
+        Process.wait(fork { command.call(args) })
+      end
+    ensure
+      client.puts
+      client.close
+    end
+
+    # The command might need to require some files in the
+    # main process so that they are cached. For example a test command wants to
+    # load the helper file once and have it cached.
+    #
+    # FIXME: The watcher.add_files will reset the watcher, which may mean that
+    #        previous changes to already-loaded files are missed.
+    def setup(command)
+      return if @setup.include?(command.class)
+      @setup << command.class
+
+      if command.respond_to?(:setup)
+        command.setup
+        watcher.add_files $LOADED_FEATURES # loaded features may have changed
+      end
+    end
+
+    def redirect_output(socket)
+      STDOUT.reopen socket.recv_io
+      STDERR.reopen socket.recv_io
+      STDIN.reopen  socket.recv_io
+
+      yield
+    ensure
+      STDOUT.reopen @stdout
+      STDERR.reopen @stderr
+      STDIN.reopen  @stdin
+    end
+  end
+end

data/lib/spring/application_manager.rb

@@ -0,0 +1,79 @@
+require "socket"
+require "spring/application"
+require "mutex_m"
+
+class Spring
+  class ApplicationManager
+    include Mutex_m
+
+    attr_reader :pid, :child, :env
+
+    def initialize(env)
+      super()
+      @env = env
+    end
+
+    def start
+      start_child
+      start_wait_thread
+    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
+
+    def alive?
+      @pid
+    end
+
+    def run(client)
+      @client = client
+
+      synchronize do
+        start unless alive?
+
+        begin
+          child.send_io @client
+        rescue Errno::EPIPE
+          # EPIPE indicates child has died but has not been collected by the wait thread yet
+          start
+          child.send_io @client
+        end
+      end
+    ensure
+      @client.close
+      @client = nil
+    end
+
+    private
+
+    def start_child(silence = false)
+      @child, child_socket = UNIXSocket.pair
+      @pid = fork {
+        [STDOUT, STDERR].each { |s| s.reopen('/dev/null', 'w') } if silence
+        @client.close if @client
+        ENV['RAILS_ENV'] = ENV['RACK_ENV'] = env
+        Application.new(child_socket).start
+      }
+      child_socket.close
+    end
+
+    def start_wait_thread
+      @wait_thread = Thread.new {
+        Thread.current.abort_on_exception = true
+
+        while alive?
+          _, status = Process.wait2(pid)
+          @pid = nil
+
+          # In the forked child, this will block forever, so we won't
+          # return to the next iteration of the loop.
+          synchronize { restart if !alive? && status.success? }
+        end
+      }
+    end
+  end
+end

data/lib/spring/application_watcher.rb

@@ -0,0 +1,40 @@
+class Spring
+  class ApplicationWatcher
+    attr_reader :mtime, :files, :globs
+
+    def initialize
+      @files = []
+      @globs = []
+      @mtime = nil
+    end
+
+    def add_files(new_files)
+      files.concat new_files.select { |f| File.exist?(f) }
+      files.uniq!
+      reset
+    end
+
+    def add_globs(new_globs)
+      globs.concat new_globs
+      reset
+    end
+
+    def reset
+      @mtime = compute_mtime
+    end
+
+    def stale?
+      mtime < compute_mtime
+    end
+
+    private
+
+    def compute_mtime
+      expanded_files.map { |f| File.mtime(f).to_f }.max || 0
+    end
+
+    def expanded_files
+      files + Dir["{#{globs.join(",")}}"]
+    end
+  end
+end

data/lib/spring/commands.rb

@@ -0,0 +1,97 @@
+# TODO: Need a way for applications to add their own commands.
+
+class Spring
+  @commands = {}
+
+  class << self
+    attr_reader :commands
+  end
+
+  def self.register_command(name, klass)
+    commands[name] = klass.new
+  end
+
+  def self.command(name)
+    commands.fetch name
+  end
+
+  module Commands
+    class Test
+      def env
+        "test"
+      end
+
+      def setup
+        $LOAD_PATH.unshift "test"
+        require "test_helper"
+      end
+
+      def call(args)
+        ARGV.replace args
+        require File.expand_path(args.first)
+      end
+    end
+    Spring.register_command "test", Test
+
+    class RSpec
+      def env
+        "test"
+      end
+
+      def setup
+        $LOAD_PATH.unshift "spec"
+        require "spec_helper"
+      end
+
+      def call(args)
+        ::RSpec::Core::Runner.run(args)
+      end
+    end
+    Spring.register_command "rspec", RSpec
+
+    class Rake
+      def setup
+        require "rake"
+      end
+
+      def call(args)
+        ARGV.replace args
+        ::Rake.application.run
+      end
+    end
+    Spring.register_command "rake", Rake
+
+    class Console
+      def setup
+        require "rails/commands/console"
+      end
+
+      def call(args)
+        ARGV.replace args
+        ::Rails::Console.start(::Rails.application)
+      end
+    end
+    Spring.register_command "console", Console
+
+    class Generate
+      def setup
+        Rails.application.load_generators
+      end
+
+      def call(args)
+        ARGV.replace args
+        require "rails/commands/generate"
+      end
+    end
+    Spring.register_command "generate", Generate
+
+    class Runner
+      def call(args)
+        Object.const_set(:APP_PATH, Rails.root.join('config/application'))
+        ARGV.replace args
+        require "rails/commands/runner"
+      end
+    end
+    Spring.register_command "runner", Runner
+  end
+end