spring_standalone 0.1.13

data/lib/spring_standalone/client/server.rb

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

data/lib/spring_standalone/client/status.rb

@@ -0,0 +1,30 @@
+module SpringStandalone
+  module Client
+    class Status < Command
+      def self.description
+        "Show current status."
+      end
+
+      def call
+        if env.server_running?
+          puts "SpringStandalone is running:"
+          puts
+          print_process env.pid
+          application_pids.each { |pid| print_process pid }
+        else
+          puts "SpringStandalone 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_standalone/client/stop.rb

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

data/lib/spring_standalone/client/version.rb

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

data/lib/spring_standalone/command_wrapper.rb

@@ -0,0 +1,82 @@
+require "spring_standalone/configuration"
+
+module SpringStandalone
+  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
+      SpringStandalone.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_standalone/commands.rb

@@ -0,0 +1,50 @@
+require "spring_standalone/watcher"
+require "spring_standalone/command_wrapper"
+
+module SpringStandalone
+  @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_standalone/commands/rails"
+  require "spring_standalone/commands/rake"
+
+  # Load custom commands, if any.
+  # needs to be at the end to allow modification of existing commands.
+  config = File.expand_path("~/.spring_standalone.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 SpringStandalone extensions which are in the Gemfile
+  Gem::Specification.map(&:name).grep(/^spring_standalone-/).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_standalone.rb")
+  require config if File.exist?(config)
+end

data/lib/spring_standalone/commands/rake.rb

@@ -0,0 +1,30 @@
+module SpringStandalone
+  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(/^(APP|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
+
+    SpringStandalone.register_command "rake", Rake.new
+  end
+end

data/lib/spring_standalone/configuration.rb

@@ -0,0 +1,58 @@
+require "spring_standalone/errors"
+
+module SpringStandalone
+  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_standalone/env.rb

@@ -0,0 +1,116 @@
+require "pathname"
+require "digest/md5"
+
+require "spring_standalone/version"
+require "spring_standalone/sid"
+require "spring_standalone/configuration"
+
+module SpringStandalone
+  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 ||= SpringStandalone.application_root_path
+    end
+
+    def project_root
+      @project_root ||= SpringStandalone.project_root_path
+    end
+
+    def version
+      SpringStandalone::VERSION
+    end
+
+    def tmp_path
+      require "tmpdir"
+      path = Pathname.new(
+        ENV["SPRING_TMP_PATH"] ||
+          File.join(ENV['XDG_RUNTIME_DIR'] || Dir.tmpdir, "spring-#{Process.uid}")
+      )
+      require "fileutils"
+      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_sa", __FILE__)} server --background"
+    end
+  end
+end

data/lib/spring_standalone/errors.rb

@@ -0,0 +1,36 @@
+module SpringStandalone
+  class ClientError < StandardError; end
+
+  class UnknownProject < StandardError
+    attr_reader :current_dir
+
+    def initialize(current_dir)
+      @current_dir = current_dir
+    end
+
+    def message
+      "SpringStandalone 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
+  #     "SpringStandalone was unable to find your config/application.rb file. " \
+  #       "Your project root was detected at #{project_root}, so SpringStandalone " \
+  #       "looked for #{project_root}/config/application.rb but it doesn't exist. You can " \
+  #       "configure the root of your application by setting SpringStandalone.application_root in " \
+  #       "config/spring.rb."
+  #   end
+  # end
+
+  class CommandNotFound < ClientError
+  end
+end