spring-jruby 1.4.3

data/lib/spring-jruby/application/boot.rb

@@ -0,0 +1,19 @@
+require "spring-jruby/platform"
+# This is necessary for the terminal to work correctly when we reopen stdin.
+Process.setsid if Spring.fork?
+
+require "spring-jruby/application"
+
+app = Spring::Application.new(
+  Spring::WorkerChannel.remote_endpoint,
+  Spring::JSON.load(ENV.delete("SPRING_ORIGINAL_ENV").dup)
+)
+
+Signal.trap("TERM") { app.terminate }
+
+Spring::ProcessTitleUpdater.run { |distance|
+  "spring app    | #{app.app_name} | started #{distance} ago | #{app.app_env} mode"
+}
+
+app.eager_preload if ENV.delete("SPRING_PRELOAD") == "1"
+app.run

data/lib/spring-jruby/binstub.rb

@@ -0,0 +1,13 @@
+command  = File.basename($0)
+bin_path = File.expand_path("../../../bin/spring", __FILE__)
+
+if command == "spring"
+  load bin_path
+else
+  disable = ENV["DISABLE_SPRING"]
+
+  if disable.nil? || disable.empty? || disable == "0"
+    ARGV.unshift(command)
+    load bin_path
+  end
+end

data/lib/spring-jruby/boot.rb

@@ -0,0 +1,9 @@
+require "socket"
+require "thread"
+
+require "spring-jruby/configuration"
+require "spring-jruby/env"
+require "spring-jruby/process_title_updater"
+require "spring-jruby/json"
+require "spring-jruby/watcher"
+require "spring-jruby/io_helpers"

data/lib/spring-jruby/client.rb

@@ -0,0 +1,46 @@
+require "spring-jruby/errors"
+require "spring-jruby/json"
+
+require "spring-jruby/client/command"
+require "spring-jruby/client/run"
+require "spring-jruby/client/help"
+require "spring-jruby/client/binstub"
+require "spring-jruby/client/stop"
+require "spring-jruby/client/status"
+require "spring-jruby/client/rails"
+require "spring-jruby/client/version"
+
+module Spring
+  module Client
+    COMMANDS = {
+      "help"      => Client::Help,
+      "-h"        => Client::Help,
+      "--help"    => Client::Help,
+      "binstub"   => Client::Binstub,
+      "stop"      => Client::Stop,
+      "status"    => Client::Status,
+      "rails"     => Client::Rails,
+      "-v"        => Client::Version,
+      "--version" => Client::Version,
+    }
+
+    def self.run(args)
+      command_for(args.first).call(args)
+    rescue CommandNotFound
+      Client::Help.call(args)
+    rescue ClientError => e
+      $stderr.puts e.message
+      exit 1
+    end
+
+    def self.command_for(name)
+      COMMANDS[name] || Client::Run
+    end
+  end
+end
+
+# allow users to add hooks that do not run in the server
+# or modify start/stop
+if File.exist?("config/spring_client.rb")
+  require "./config/spring_client.rb"
+end

data/lib/spring-jruby/client/binstub.rb

@@ -0,0 +1,188 @@
+require 'set'
+
+module Spring
+  module Client
+    class Binstub < Command
+      SHEBANG = /\#\!.*\n/
+
+      # If loading the bin/spring file works, it'll run spring which will
+      # eventually call Kernel.exit. This means that in the client process
+      # we will never execute the lines after this block. But if the spring
+      # client is not invoked for whatever reason, then the Kernel.exit won't
+      # happen, and so we'll fall back to the lines after this block, which
+      # should cause the "unsprung" version of the command to run.
+      LOADER = <<CODE
+begin
+  load File.expand_path('../spring', __FILE__)
+rescue LoadError
+end
+CODE
+
+      # The defined? check ensures these lines don't execute when we load the
+      # binstub from the application process. Which means that in the application
+      # process we'll execute the lines which come after the LOADER block, which
+      # is what we want.
+      #
+      # Parsing the lockfile in this way is pretty nasty but reliable enough
+      # The regex ensures that the match must be between a GEM line and an empty
+      # line, so it won't go on to the next section.
+      SPRING = <<'CODE'
+#!/usr/bin/env ruby
+
+# This file loads spring without using Bundler, in order to be fast.
+# It gets overwritten when you run the `spring binstub` command.
+
+unless defined?(Spring)
+  require 'rubygems'
+  require 'bundler'
+
+  if (match = Bundler.default_lockfile.read.match(/^GEM$.*?^    (?:  )*spring-jruby \((.*?)\)$.*?^$/m))
+    Gem.paths = { 'GEM_PATH' => [Bundler.bundle_path.to_s, *Gem.path].uniq }
+    gem 'spring-jruby', match[1]
+    require 'spring-jruby/binstub'
+  end
+end
+CODE
+
+      OLD_BINSTUB = %{if Gem::Specification.find_all_by_name("spring-jruby").empty?}
+
+      class Item
+        attr_reader :command, :existing
+
+        def initialize(command)
+          @command = command
+
+          if command.binstub.exist?
+            @existing = command.binstub.read
+          elsif command.name == "rails"
+            scriptfile = Spring.application_root_path.join("script/rails")
+            @existing = scriptfile.read if scriptfile.exist?
+          end
+        end
+
+        def status(text, stream = $stdout)
+          stream.puts "* #{command.binstub_name}: #{text}"
+        end
+
+        def add
+          if existing
+            if existing.include?(OLD_BINSTUB)
+              fallback = existing.match(/#{Regexp.escape OLD_BINSTUB}\n(.*)else/m)[1]
+              fallback.gsub!(/^  /, "")
+              fallback = nil if fallback.include?("exec")
+              generate(fallback)
+              status "upgraded"
+            elsif existing =~ /load .*spring-jruby/
+              status "spring already present"
+            else
+              head, shebang, tail = existing.partition(SHEBANG)
+
+              if shebang.include?("ruby")
+                unless command.binstub.exist?
+                  FileUtils.touch command.binstub
+                  command.binstub.chmod 0755
+                end
+
+                File.write(command.binstub, "#{head}#{shebang}#{LOADER}#{tail}")
+                status "spring inserted"
+              else
+                status "doesn't appear to be ruby, so cannot use spring", $stderr
+                exit 1
+              end
+            end
+          else
+            generate
+            status "generated with spring"
+          end
+        end
+
+        def generate(fallback = nil)
+          unless fallback
+            fallback = "require 'bundler/setup'\n" \
+                       "load Gem.bin_path('#{command.gem_name}', '#{command.exec_name}')\n"
+          end
+
+          File.write(command.binstub, "#!/usr/bin/env ruby\n#{LOADER}#{fallback}")
+          command.binstub.chmod 0755
+        end
+
+        def remove
+          if existing
+            File.write(command.binstub, existing.sub(LOADER, ""))
+            status "spring removed"
+          end
+        end
+      end
+
+      attr_reader :bindir, :items
+
+      def self.description
+        "Generate spring based binstubs. Use --all to generate a binstub for all known commands."
+      end
+
+      def self.rails_command
+        @rails_command ||= CommandWrapper.new("rails")
+      end
+
+      def self.call(args)
+        require "spring-jruby/commands"
+        super
+      end
+
+      def initialize(args)
+        super
+
+        @bindir = env.root.join("bin")
+        @all    = false
+        @mode   = :add
+        @items  = args.drop(1)
+                      .map { |name| find_commands name }
+                      .inject(Set.new, :|)
+                      .map { |command| Item.new(command) }
+      end
+
+      def find_commands(name)
+        case name
+        when "--all"
+          @all = true
+          commands = Spring.commands.dup
+          commands.delete_if { |command_name, _| command_name.start_with?("rails_") }
+          commands.values + [self.class.rails_command]
+        when "--remove"
+          @mode = :remove
+          []
+        when "rails"
+          [self.class.rails_command]
+        else
+          if command = Spring.commands[name]
+            [command]
+          else
+            $stderr.puts "The '#{name}' command is not known to spring."
+            exit 1
+          end
+        end
+      end
+
+      def call
+        case @mode
+        when :add
+          bindir.mkdir unless bindir.exist?
+
+          File.write(spring_binstub, SPRING)
+          spring_binstub.chmod 0755
+
+          items.each(&:add)
+        when :remove
+          spring_binstub.delete if @all
+          items.each(&:remove)
+        else
+          raise ArgumentError
+        end
+      end
+
+      def spring_binstub
+        bindir.join("spring")
+      end
+    end
+  end
+end

data/lib/spring-jruby/client/command.rb

@@ -0,0 +1,18 @@
+require "spring-jruby/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-jruby/client/help.rb

@@ -0,0 +1,62 @@
+require "spring-jruby/version"
+
+module Spring
+  module Client
+    class Help < Command
+      attr_reader :spring_commands, :application_commands
+
+      def self.description
+        "Print available commands."
+      end
+
+      def self.call(args)
+        require "spring-jruby/commands"
+        super
+      end
+
+      def initialize(args, spring_commands = nil, application_commands = nil)
+        super args
+
+        @spring_commands      = spring_commands      || Spring::Client::COMMANDS.dup
+        @application_commands = application_commands || Spring.commands.dup
+
+        @spring_commands.delete_if { |k, v| k.start_with?("-") }
+
+        @application_commands["rails"] = @spring_commands.delete("rails")
+      end
+
+      def call
+        puts formatted_help
+      end
+
+      def formatted_help
+        ["Version: #{env.version}\n",
+         "Usage: spring COMMAND [ARGS]\n",
+         *command_help("spring itself", spring_commands),
+         '',
+         *command_help("your application", application_commands)].join("\n")
+      end
+
+      def command_help(subject, commands)
+        ["Commands for #{subject}:\n",
+        *commands.sort_by(&:first).map { |name, command| display(name, command) }.compact]
+      end
+
+      private
+
+      def all_commands
+        spring_commands.merge application_commands
+      end
+
+      def display(name, command)
+        if command.description
+          "  #{name.ljust(max_name_width)}  #{command.description}"
+        end
+      end
+
+      def max_name_width
+        @max_name_width ||= all_commands.keys.map(&:length).max
+      end
+    end
+  end
+end

data/lib/spring-jruby/client/rails.rb

@@ -0,0 +1,34 @@
+require "set"
+
+module Spring
+  module Client
+    class Rails < Command
+      COMMANDS = Set.new %w(console runner generate destroy test)
+
+      ALIASES = {
+        "c" => "console",
+        "r" => "runner",
+        "g" => "generate",
+        "d" => "destroy",
+        "t" => "test"
+      }
+
+      def self.description
+        "Run a rails command. The following sub commands will use spring: #{COMMANDS.to_a.join ', '}."
+      end
+
+      def call
+        command_name = ALIASES[args[1]] || args[1]
+
+        if COMMANDS.include?(command_name)
+          Run.call(["rails_#{command_name}", *args.drop(2)])
+        else
+          require "spring-jruby/configuration"
+          ARGV.shift
+          load Dir.glob(Spring.application_root_path.join("{bin,script}/rails")).first
+          exit
+        end
+      end
+    end
+  end
+end

data/lib/spring-jruby/client/run.rb

@@ -0,0 +1,167 @@
+require "rbconfig"
+require "socket"
+require "bundler"
+require "spring-jruby/io_helpers"
+require "spring-jruby/impl/run"
+
+module Spring
+  module Client
+    class Run < Command
+      include RunImpl
+      TIMEOUT = RunImpl::TIMEOUT
+
+      def initialize(args)
+        super
+        @signal_queue = []
+      end
+
+      def log(message)
+        env.log "[client] #{message}"
+      end
+
+      def server
+        @server ||= UNIXSocket.open(env.socket_name)
+      end
+
+      def call
+        if env.server_running?
+          warm_run
+        else
+          cold_run
+        end
+      rescue Errno::ECONNRESET
+        exit 1
+      ensure
+        server.close if @server
+      end
+
+      def warm_run
+        run
+      rescue CommandNotFound
+        require "spring-jruby/commands"
+
+        if Spring.command?(args.first)
+          # Command installed since spring started
+          stop_server
+          cold_run
+        else
+          raise
+        end
+      end
+
+      def cold_run
+        boot_server
+        run
+      end
+
+      def run
+        verify_server_version
+
+        application, client = WorkerChannel.pair
+
+        queue_signals
+        connect_to_application(client)
+        run_command(client, application.to_io)
+      end
+
+      def boot_server
+        env.socket_path.unlink if env.socket_path.exist?
+
+        pid = Process.spawn(
+          gem_env,
+          "ruby",
+          "-e", "gem 'spring-jruby', '#{Spring::VERSION}'; require 'spring-jruby/server'; Spring::Server.boot"
+        )
+
+        until env.socket_path.exist?
+          _, status = Process.waitpid2(pid, Process::WNOHANG)
+          exit status.exitstatus if status
+          sleep 0.1
+        end
+      end
+
+      def gem_env
+        bundle = Bundler.bundle_path.to_s
+        paths  = Gem.path + ENV["GEM_PATH"].to_s.split(File::PATH_SEPARATOR)
+
+        {
+          "GEM_PATH" => [bundle, *paths].uniq.join(File::PATH_SEPARATOR),
+          "GEM_HOME" => bundle
+        }
+      end
+
+      def stop_server
+        server.close
+        @server = nil
+        env.stop
+      end
+
+      def verify_server_version
+        server_version = server.gets.chomp
+        if server_version != env.version
+          $stderr.puts <<-ERROR
+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}
+ERROR
+          exit 1
+        end
+      end
+
+      def connect_to_application(client)
+        client.forward_to(server)
+        send_json server, "args" => args, "default_rails_env" => default_rails_env
+
+        if IO.select([server], [], [], TIMEOUT)
+          server.gets or raise CommandNotFound
+        else
+          raise "Error connecting to Spring server"
+        end
+      end
+
+      def run_command(client, application)
+        log "sending command"
+
+        send_std_io_to(application)
+
+        send_json application, "args" => args, "env" => ENV.to_hash
+
+        IO.select([server])
+        pid = server.gets
+        pid = pid.chomp if pid
+
+        # 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 && !pid.empty?
+          log "got pid: #{pid}"
+
+          run_on(application, pid)
+        else
+          log "got no pid"
+          exit 1
+        end
+      ensure
+        application.close
+      end
+
+      def kill(sig, pid)
+        Process.kill(sig, -Process.getpgid(pid))
+      end
+
+      def send_json(socket, data)
+        data = JSON.dump(data)
+
+        socket.puts  data.bytesize
+        socket.write data
+      end
+
+      def default_rails_env
+        ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+      end
+    end
+  end
+end