nrispring 2.1.1

data/lib/spring/client/server.rb

@@ -0,0 +1,18 @@
+module Spring
+  module Client
+    class Server < Command
+      def self.description
+        "Explicitly start a Spring server in the foreground"
+      end
+
+      def call
+        require "spring/server"
+        Spring::Server.boot(foreground: foreground?)
+      end
+
+      def foreground?
+        !args.include?("--background")
+      end
+    end
+  end
+end

data/lib/spring/client/status.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Client
+    class Status < Command
+      def self.description
+        "Show current status."
+      end
+
+      def call
+        if env.server_running?
+          puts "Spring is running:"
+          puts
+          print_process env.pid
+          application_pids.each { |pid| print_process pid }
+        else
+          puts "Spring is not running."
+        end
+      end
+
+      def print_process(pid)
+        puts `ps -p #{pid} -o pid= -o command=`
+      end
+
+      def application_pids
+        candidates = `ps -ax -o ppid= -o pid=`.lines
+        candidates.select { |l| l =~ /^(\s+)?#{env.pid} / }
+                  .map    { |l| l.split(" ").last   }
+      end
+    end
+  end
+end

data/lib/spring/client/stop.rb

@@ -0,0 +1,22 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Stop < Command
+      def self.description
+        "Stop all Spring processes for this project."
+      end
+
+      def call
+        case env.stop
+        when :stopped
+          puts "Spring stopped."
+        when :killed
+          $stderr.puts "Spring did not stop; killing forcibly."
+        when :not_running
+          puts "Spring is not running"
+        end
+      end
+    end
+  end
+end

data/lib/spring/client/version.rb

@@ -0,0 +1,11 @@
+require "spring/version"
+
+module Spring
+  module Client
+    class Version < Command
+      def call
+        puts "Spring version #{Spring::VERSION}"
+      end
+    end
+  end
+end

data/lib/spring/command_wrapper.rb

@@ -0,0 +1,82 @@
+require "spring/configuration"
+
+module Spring
+  class CommandWrapper
+    attr_reader :name, :command
+
+    def initialize(name, command = nil)
+      @name    = name
+      @command = command
+      @setup   = false
+    end
+
+    def description
+      if command.respond_to?(:description)
+        command.description
+      else
+        "Runs the #{name} command"
+      end
+    end
+
+    def setup?
+      @setup
+    end
+
+    def setup
+      if !setup? && command.respond_to?(:setup)
+        command.setup
+        @setup = true
+        return true
+      else
+        @setup = true
+        return false
+      end
+    end
+
+    def call
+      if command.respond_to?(:call)
+        command.call
+      else
+        load exec
+      end
+    end
+
+    def gem_name
+      if command.respond_to?(:gem_name)
+        command.gem_name
+      else
+        exec_name
+      end
+    end
+
+    def exec_name
+      if command.respond_to?(:exec_name)
+        command.exec_name
+      else
+        name
+      end
+    end
+
+    def binstub
+      Spring.application_root_path.join(binstub_name)
+    end
+
+    def binstub_name
+      "bin/#{name}"
+    end
+
+    def exec
+      if binstub.exist?
+        binstub.to_s
+      else
+        Gem.bin_path(gem_name, exec_name)
+      end
+    end
+
+    def env(args)
+      if command.respond_to?(:env)
+        command.env(args)
+      end
+    end
+  end
+end

data/lib/spring/commands.rb

@@ -0,0 +1,50 @@
+require "spring/watcher"
+require "spring/command_wrapper"
+
+module Spring
+  @commands = {}
+
+  class << self
+    attr_reader :commands
+  end
+
+  def self.register_command(name, command = nil)
+    commands[name] = CommandWrapper.new(name, command)
+  end
+
+  def self.command?(name)
+    commands.include? name
+  end
+
+  def self.command(name)
+    commands.fetch name
+  end
+
+  require "spring/commands/rails"
+  require "spring/commands/rake"
+
+  # Load custom commands, if any.
+  # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("~/.spring.rb")
+  require config if File.exist?(config)
+
+  # If the config/spring.rb contains requires for commands from other gems,
+  # then we need to be under bundler.
+  require "bundler/setup"
+
+  # Auto-require any Spring extensions which are in the Gemfile
+  Gem::Specification.map(&:name).grep(/^spring-/).each do |command|
+    begin
+      require command
+    rescue LoadError => error
+      if error.message.include?(command)
+        require command.gsub("-", "/")
+      else
+        raise
+      end
+    end
+  end
+
+  config = File.expand_path("./config/spring.rb")
+  require config if File.exist?(config)
+end

data/lib/spring/commands/rails.rb

@@ -0,0 +1,112 @@
+module Spring
+  module Commands
+    class Rails
+      def call
+        ARGV.unshift command_name
+        load Dir.glob(::Rails.root.join("{bin,script}/rails")).first
+      end
+
+      def description
+        nil
+      end
+    end
+
+    class RailsConsole < Rails
+      def env(args)
+        return args.first if args.first && !args.first.index("-")
+
+        environment = nil
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "console"
+      end
+    end
+
+    class RailsGenerate < Rails
+      def command_name
+        "generate"
+      end
+    end
+
+    class RailsDestroy < Rails
+      def command_name
+        "destroy"
+      end
+    end
+
+    class RailsRunner < Rails
+      def call
+        ARGV.replace extract_environment(ARGV).first
+        super
+      end
+
+      def env(args)
+        extract_environment(args).last
+      end
+
+      def command_name
+        "runner"
+      end
+
+      def extract_environment(args)
+        environment = nil
+
+        args = args.select.with_index { |arg, i|
+          case arg
+          when "-e"
+            false
+          when /--environment=(\w+)/
+            environment = $1
+            false
+          else
+            if i > 0 && args[i - 1] == "-e"
+              environment = arg
+              false
+            else
+              true
+            end
+          end
+        }
+
+        [args, environment]
+      end
+    end
+
+    class RailsTest < Rails
+      def env(args)
+        environment = "test"
+
+        args.each.with_index do |arg, i|
+          if arg =~ /--environment=(\w+)/
+            environment = $1
+          elsif i > 0 && args[i - 1] == "-e"
+            environment = arg
+          end
+        end
+
+        environment
+      end
+
+      def command_name
+        "test"
+      end
+    end
+
+    Spring.register_command "rails_console",  RailsConsole.new
+    Spring.register_command "rails_generate", RailsGenerate.new
+    Spring.register_command "rails_destroy",  RailsDestroy.new
+    Spring.register_command "rails_runner",   RailsRunner.new
+    Spring.register_command "rails_test",     RailsTest.new
+  end
+end

data/lib/spring/commands/rake.rb

@@ -0,0 +1,30 @@
+module Spring
+  module Commands
+    class Rake
+      class << self
+        attr_accessor :environment_matchers
+      end
+
+      self.environment_matchers = {
+        :default     => "test",
+        /^test($|:)/ => "test"
+      }
+
+      def env(args)
+        # This is an adaption of the matching that Rake itself does.
+        # See: https://github.com/jimweirich/rake/blob/3754a7639b3f42c2347857a0878beb3523542aee/lib/rake/application.rb#L691-L692
+        if env = args.grep(/^(RAILS|RACK)_ENV=(.*)$/m).last
+          return env.split("=").last
+        end
+
+        self.class.environment_matchers.each do |matcher, environment|
+          return environment if matcher === (args.first || :default)
+        end
+
+        nil
+      end
+    end
+
+    Spring.register_command "rake", Rake.new
+  end
+end

data/lib/spring/configuration.rb

@@ -0,0 +1,58 @@
+require "spring/errors"
+
+module Spring
+  class << self
+    attr_accessor :application_root, :quiet
+
+    def gemfile
+      if /\s1.9.[0-9]/ ===  Bundler.ruby_scope.gsub(/[\/\s]+/,'')
+        ENV["BUNDLE_GEMFILE"] || "Gemfile"
+      else
+        Bundler.default_gemfile
+      end
+    end
+
+    def after_fork_callbacks
+      @after_fork_callbacks ||= []
+    end
+
+    def after_fork(&block)
+      after_fork_callbacks << block
+    end
+
+    def verify_environment
+      application_root_path
+    end
+
+    def application_root_path
+      @application_root_path ||= begin
+        if application_root
+          path = Pathname.new(File.expand_path(application_root))
+        else
+          path = project_root_path
+        end
+
+        raise MissingApplication.new(path) unless path.join("config/application.rb").exist?
+        path
+      end
+    end
+
+    def project_root_path
+      @project_root_path ||= find_project_root(Pathname.new(File.expand_path(Dir.pwd)))
+    end
+
+    private
+
+    def find_project_root(current_dir)
+      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
+
+  self.quiet = false
+end

data/lib/spring/env.rb

@@ -0,0 +1,116 @@
+require "pathname"
+require "fileutils"
+require "digest/md5"
+require "tmpdir"
+
+require "spring/version"
+require "spring/sid"
+require "spring/configuration"
+
+module Spring
+  IGNORE_SIGNALS = %w(INT QUIT)
+  STOP_TIMEOUT = 2 # seconds
+
+  class Env
+    attr_reader :log_file
+
+    def initialize(options = {})
+      @root         = options[:root]
+      @project_root = options[:root]
+      @log_file     = options[:log_file] || File.open(ENV["SPRING_LOG"] || File::NULL, "a")
+    end
+
+    def root
+      @root ||= Spring.application_root_path
+    end
+
+    def project_root
+      @project_root ||= Spring.project_root_path
+    end
+
+    def version
+      Spring::VERSION
+    end
+
+    def tmp_path
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
+      FileUtils.mkdir_p(path) unless path.exist?
+      path
+    end
+
+    def application_id
+      ENV["SPRING_APPLICATION_ID"] || Digest::MD5.hexdigest(RUBY_VERSION + project_root.to_s)
+    end
+
+    def socket_path
+      Pathname.new(ENV["SPRING_SOCKET"] || tmp_path.join(application_id))
+    end
+
+    def socket_name
+      socket_path.to_s
+    end
+
+    def pidfile_path
+      Pathname.new(ENV["SPRING_PIDFILE"] || socket_path.dirname.join("#{socket_path.basename(".*")}.pid"))
+    end
+
+    def pid
+      pidfile_path.exist? ? pidfile_path.read.to_i : nil
+    rescue Errno::ENOENT
+      # This can happen if the pidfile is removed after we check it
+      # exists
+    end
+
+    def app_name
+      root.basename
+    end
+
+    def server_running?
+      pidfile = pidfile_path.open('r+')
+      !pidfile.flock(File::LOCK_EX | File::LOCK_NB)
+    rescue Errno::ENOENT
+      false
+    ensure
+      if pidfile
+        pidfile.flock(File::LOCK_UN)
+        pidfile.close
+      end
+    end
+
+    def log(message)
+      log_file.puts "[#{Time.now}] [#{Process.pid}] #{message}"
+      log_file.flush
+    end
+
+    def stop
+      if server_running?
+        timeout = Time.now + STOP_TIMEOUT
+        kill 'TERM'
+        sleep 0.1 until !server_running? || Time.now >= timeout
+
+        if server_running?
+          kill 'KILL'
+          :killed
+        else
+          :stopped
+        end
+      else
+        :not_running
+      end
+    end
+
+    def kill(sig)
+      pid = self.pid
+      Process.kill(sig, pid) if pid
+    rescue Errno::ESRCH
+      # already dead
+    end
+
+    def server_command
+      ENV["SPRING_SERVER_COMMAND"] || "#{File.expand_path("../../../bin/spring", __FILE__)} server --background"
+    end
+  end
+end