spring-jruby 1.4.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b99ce59145a28c1dc4d73025347f9158c552d467
+  data.tar.gz: bda2cd1aa00702f9f1076d0acaf2fac62e634912
+SHA512:
+  metadata.gz: 47265df7a11d37b58319107153223527763fc7b5c35f46d8f1d03f2c9e657250659fae309eb213bda5d29d96c0d82e528aa3a42ab1fec0307e97a226f757ec1f
+  data.tar.gz: 92965eeb3c5c9ef83ef4b5761428ddb18b20bebbc5c3170308eb06ab5efefde6f470f788524bef5aebdbaccefeb5da48fd68041770d37e1c0e5af8aa1c5625f8

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,364 @@
+# Spring
+
+[![Build Status](https://travis-ci.org/rails/spring.svg?branch=master)](https://travis-ci.org/rails/spring)
+[![Gem Version](https://badge.fury.io/rb/spring.svg)](http://badge.fury.io/rb/spring)
+
+Spring is a Rails application preloader. It speeds up development by
+keeping your application running in the background so you don't need to
+boot it every time you run a test, rake task or migration.
+
+## Features
+
+* Totally automatic; no need to explicitly start and stop the background process
+* Reloads your application code on each run
+* Restarts your application when configs / initializers / gem
+  dependencies are changed
+
+## Compatibility
+
+* Ruby versions: MRI 1.9.3, MRI 2.0, MRI 2.1
+* Rails versions: 4.0+ (in Rails 4.1 and up Spring is included by default)
+
+Spring makes extensive use of `Process.fork`, so won't be able to
+provide a speed up on platforms which don't support forking (Windows, JRuby).
+
+## Walkthrough
+
+### Setup
+
+Add spring to your Gemfile:
+
+``` ruby
+gem "spring", group: :development
+```
+
+(Note: using `gem "spring", git: "..."` *won't* work and is not a
+supported way of using spring.)
+
+It's recommended to 'springify' the executables in your `bin/`
+directory:
+
+```
+$ bundle install
+$ bundle exec spring binstub --all
+```
+
+This generates a `bin/spring` executable, and inserts a small snippet of
+code into relevant existing executables. The snippet looks like this:
+
+``` ruby
+begin
+  load File.expand_path('../spring', __FILE__)
+rescue LoadError
+end
+```
+
+On platforms where spring is installed and supported, this snippet
+hooks spring into the execution of commands. In other cases, the snippet
+will just be silently ignored and the lines after it will be executed as
+normal.
+
+If you don't want to prefix every command you type with `bin/`, you
+can [use direnv](https://github.com/zimbatm/direnv#the-stdlib) to
+automatically add `./bin` to your `PATH` when you `cd` into your application.
+Simply create an `.envrc` file with the command `PATH_add bin` in your
+Rails directory.
+
+### Usage
+
+For this walkthrough I've generated a new Rails application, and run
+`rails generate scaffold post name:string`.
+
+Let's run a test:
+
+```
+$ time bin/rake test test/controllers/posts_controller_test.rb
+Run options:
+
+# Running tests:
+
+.......
+
+Finished tests in 0.127245s, 55.0121 tests/s, 78.5887 assertions/s.
+
+7 tests, 10 assertions, 0 failures, 0 errors, 0 skips
+
+real    0m2.165s
+user    0m0.281s
+sys     0m0.066s
+```
+
+That wasn't particularly fast because it was the first run, so spring
+had to boot the application. It's now running:
+
+```
+$ bin/spring status
+Spring is running:
+
+26150 spring server | spring-demo-app | started 3 secs ago
+26155 spring app    | spring-demo-app | started 3 secs ago | test mode
+```
+
+The next run is faster:
+
+```
+$ time bin/rake test test/controllers/posts_controller_test.rb
+Run options:
+
+# Running tests:
+
+.......
+
+Finished tests in 0.176896s, 39.5714 tests/s, 56.5305 assertions/s.
+
+7 tests, 10 assertions, 0 failures, 0 errors, 0 skips
+
+real    0m0.610s
+user    0m0.276s
+sys     0m0.059s
+```
+
+If we edit any of the application files, or test files, the changes will
+be picked up on the next run without the background process having to
+restart. This works in exactly the same way as the code reloading
+which allows you to refresh your browser and instantly see changes during
+development.
+
+But if we edit any of the files which were used to start the application
+(configs, initializers, your gemfile), the application needs to be fully
+restarted. This happens automatically.
+
+Let's "edit" `config/application.rb`:
+
+```
+$ touch config/application.rb
+$ bin/spring status
+Spring is running:
+
+26150 spring server | spring-demo-app | started 36 secs ago
+26556 spring app    | spring-demo-app | started 1 sec ago | test mode
+```
+
+The application detected that `config/application.rb` changed and
+automatically restarted itself.
+
+If we run a command that uses a different environment, then that
+environment gets booted up:
+
+```
+$ bin/rake routes
+    posts GET    /posts(.:format)          posts#index
+          POST   /posts(.:format)          posts#create
+ new_post GET    /posts/new(.:format)      posts#new
+edit_post GET    /posts/:id/edit(.:format) posts#edit
+     post GET    /posts/:id(.:format)      posts#show
+          PUT    /posts/:id(.:format)      posts#update
+          DELETE /posts/:id(.:format)      posts#destroy
+
+$ bin/spring status
+Spring is running:
+
+26150 spring server | spring-demo-app | started 1 min ago
+26556 spring app    | spring-demo-app | started 42 secs ago | test mode
+26707 spring app    | spring-demo-app | started 2 secs ago | development mode
+```
+
+There's no need to "shut down" spring. This will happen automatically
+when you close your terminal. However if you do want to do a manual shut
+down, use the `stop` command:
+
+```
+$ bin/spring stop
+Spring stopped.
+```
+
+### Removal
+
+To remove spring:
+
+* 'Unspring' your bin/ executables: `bin/spring binstub --remove --all`
+* Remove spring from your Gemfile
+
+### Deployment
+
+You must not install Spring on your production environment. To prevent it from
+being installed, provide the `--without development test` argument to the
+`bundle install` command which is used to install gems on your production
+machines:
+
+```
+$ bundle install --without development test
+```
+
+## Commands
+
+### `rake`
+
+Runs a rake task. Rake tasks run in the `development` environment by
+default. You can change this on the fly by using the `RAILS_ENV`
+environment variable. The environment is also configurable with the
+`Spring::Commands::Rake.environment_matchers` hash. This has sensible
+defaults, but if you need to match a specific task to a specific
+environment, you'd do it like this:
+
+``` ruby
+Spring::Commands::Rake.environment_matchers["perf_test"] = "test"
+Spring::Commands::Rake.environment_matchers[/^perf/]     = "test"
+
+# To change the environment when you run `rake` with no arguments
+Spring::Commands::Rake.environment_matchers[:default] = "development"
+```
+
+### `rails console`, `rails generate`, `rails runner`
+
+These execute the rails command you already know and love. If you run
+a different sub command (e.g. `rails server`) then spring will automatically
+pass it through to the underlying `rails` executable (without the
+speed-up).
+
+### Additional commands
+
+You can add these to your Gemfile for additional commands:
+
+* [spring-commands-rspec](https://github.com/jonleighton/spring-commands-rspec)
+* [spring-commands-cucumber](https://github.com/jonleighton/spring-commands-cucumber)
+* [spring-commands-spinach](https://github.com/jvanbaarsen/spring-commands-spinach)
+* [spring-commands-testunit](https://github.com/jonleighton/spring-commands-testunit) - useful for
+  running `Test::Unit` tests on Rails 3, since only Rails 4 allows you
+  to use `rake test path/to/test` to run a particular test/directory.
+* [spring-commands-teaspoon](https://github.com/alejandrobabio/spring-commands-teaspoon.git)
+* [spring-commands-m](https://github.com/gabrieljoelc/spring-commands-m.git)
+
+## Use without adding to bundle
+
+If you don't want spring-related code checked into your source
+repository, it's possible to use spring without adding to your Gemfile.
+However, using spring binstubs without adding spring to the Gemfile is not
+supported.
+
+To use spring like this, do a `gem install spring` and then prefix
+commands with `spring`. For example, rather than running `bin/rake -T`,
+you'd run `spring rake -T`.
+
+## Temporarily disabling Spring
+
+If you're using Spring binstubs, but temporarily don't want commands to
+run through Spring, set the `DISABLE_SPRING` environment variable.
+
+## Class reloading
+
+Spring uses Rails' class reloading mechanism
+(`ActiveSupport::Dependencies`) to keep your code up to date between
+test runs. This is the same mechanism which allows you to see changes
+during development when you refresh the page. However, you may never
+have used this mechanism with your `test` environment before, and this
+can cause problems.
+
+It's important to realise that code reloading means that the constants
+in your application are *different objects* after files have changed:
+
+```
+$ bin/rails runner 'puts User.object_id'
+70127987886040
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User.object_id'
+70127976764620
+```
+
+Suppose you have an initializer `config/initializers/save_user_class.rb`
+like so:
+
+``` ruby
+USER_CLASS = User
+```
+
+This saves off the *first* version of the `User` class, which will not
+be the same object as `User` after the code has been reloaded:
+
+```
+$ bin/rails runner 'puts User == USER_CLASS'
+true
+$ touch app/models/user.rb
+$ bin/rails runner 'puts User == USER_CLASS'
+false
+```
+
+So to avoid this problem, don't save off references to application
+constants in your initialization code.
+
+## Configuration
+
+Spring will read `~/.spring.rb` and `config/spring.rb` for custom
+settings. Note that `~/.spring.rb` is loaded *before* bundler, but
+`config/spring.rb` is loaded *after* bundler. So if you have any
+`spring-commands-*` gems installed that you want to be available in all
+projects without having to be added to the project's Gemfile, require
+them in your `~/.spring.rb`.
+
+`config/spring_client.rb` is also loaded before bundler and before a
+server process is started, it can be used to add new top-level commands.
+
+### Application root
+
+Spring must know how to find your Rails application. If you have a
+normal app everything works out of the box. If you are working on a
+project with a special setup (an engine for example), you must tell
+Spring where your app is located:
+
+```ruby
+Spring.application_root = './test/dummy'
+```
+
+### Running code before forking
+
+There is no `Spring.before_fork` callback. To run something before the
+fork, you can place it in `~/.spring.rb` or `config/spring.rb` or in any of the files
+which get run when your application initializes, such as
+`config/application.rb`, `config/environments/*.rb` or
+`config/initializers/*.rb`.
+
+### Running code after forking
+
+You might want to run code after Spring forked off the process but
+before the actual command is run. You might want to use an
+`after_fork` callback if you have to connect to an external service,
+do some general cleanup or set up dynamic configuration.
+
+```ruby
+Spring.after_fork do
+  # run arbitrary code
+end
+```
+
+If you want to register multiple callbacks you can simply call
+`Spring.after_fork` multiple times with different blocks.
+
+### Watching files and directories
+
+Spring will automatically detect file changes to any file loaded when the server
+boots. Changes will cause the affected environments to be restarted.
+
+If there are additional files or directories which should trigger an
+application restart, you can specify them with `Spring.watch`:
+
+```ruby
+Spring.watch "config/some_config_file.yml"
+```
+
+By default Spring polls the filesystem for changes once every 0.2 seconds. This
+method requires zero configuration, but if you find that it's using too
+much CPU, then you can use event-based file system listening by
+installing the
+[spring-watcher-listen](https://github.com/jonleighton/spring-watcher-listen)
+gem.
+
+## Troubleshooting
+
+If you want to get more information about what spring is doing, you can
+specify a log file with the `SPRING_LOG` environment variable:
+
+```
+spring stop # if spring is already running
+export SPRING_LOG=/tmp/spring.log
+spring rake -T
+```

data/bin/spring

@@ -0,0 +1,49 @@
+#!/usr/bin/env ruby
+
+if defined?(Spring)
+  $stderr.puts "You've tried to invoke Spring when it's already loaded (i.e. the Spring " \
+               "constant is defined)."
+  $stderr.puts
+  $stderr.puts "This is probably because you generated binstubs with " \
+               "Spring 1.0, and you now have a Spring version > 1.0 on your system. To solve " \
+               "this, upgrade your bundle to the latest Spring version and then run " \
+               "`bundle exec spring binstub --all` to regenerate your binstubs. This is a one-time " \
+               "step necessary to upgrade from 1.0 to 1.1."
+  $stderr.puts
+  $stderr.puts "Here's the backtrace:"
+  $stderr.puts
+  $stderr.puts caller
+  exit 1
+end
+
+if defined?(Gem)
+  if Gem::Version.new(Gem::VERSION) < Gem::Version.new("2.1.0")
+    warn "Warning: You're using Rubygems #{Gem::VERSION} with Spring. " \
+         "Upgrade to at least Rubygems 2.1.0 and run `gem pristine --all` for better " \
+         "startup performance."
+  else
+    stubs = Gem::Specification.stubs.grep(Gem::StubSpecification)
+
+    # stubbed? method added in https://github.com/rubygems/rubygems/pull/694
+    if Gem::Specification.stubs.first.respond_to?(:stubbed?)
+      unstubbed = stubs.reject(&:stubbed?)
+    else
+      unstubbed = stubs.reject { |s| s.send(:data).is_a?(Gem::StubSpecification::StubLine) }
+    end
+
+    # `gem pristine --all` ignores default gems. it doesn't really matter,
+    # as there are probably not many of them on the system.
+    unstubbed.reject!(&:default_gem?)
+
+    if unstubbed.any?
+      warn "Warning: Running `gem pristine --all` to regenerate your installed gemspecs " \
+           "(and deleting then reinstalling your bundle if you use bundle --path) " \
+           "will improve the startup performance of Spring."
+    end
+  end
+end
+
+lib = File.expand_path("../../lib", __FILE__)
+$LOAD_PATH.unshift lib unless $LOAD_PATH.include?(lib) # enable local development
+require 'spring-jruby/client'
+Spring::Client.run(ARGV)

data/lib/spring-jruby/application.rb

@@ -0,0 +1,283 @@
+require "spring-jruby/boot"
+require "set"
+require "pty"
+require "spring-jruby/impl/application"
+
+module Spring
+  class Application
+    include ApplicationImpl
+    attr_reader :manager, :watcher, :spring_env, :original_env
+
+    def initialize(manager, original_env)
+      @manager      = manager
+      @original_env = original_env
+      @spring_env   = Env.new
+      @mutex        = Mutex.new
+      @waiting      = Set.new
+      @preloaded    = false
+      @state        = :initialized
+      @interrupt    = IO.pipe
+    end
+
+    def state(val)
+      return if exiting?
+      log "#{@state} -> #{val}"
+      @state = val
+    end
+
+    def state!(val)
+      state val
+      @interrupt.last.write "."
+    end
+
+    def app_env
+      ENV['RAILS_ENV']
+    end
+
+    def app_name
+      spring_env.app_name
+    end
+
+    def log(message)
+      spring_env.log "[application:#{app_env}] #{message}"
+    end
+
+    def preloaded?
+      @preloaded
+    end
+
+    def preload_failed?
+      @preloaded == :failure
+    end
+
+    def exiting?
+      @state == :exiting
+    end
+
+    def terminating?
+      @state == :terminating
+    end
+
+    def watcher_stale?
+      @state == :watcher_stale
+    end
+
+    def initialized?
+      @state == :initialized
+    end
+
+    def start_watcher
+      @watcher = Spring.watcher
+      @watcher.on_stale { state! :watcher_stale }
+      @watcher.start
+    end
+
+    def preload
+      log "preloading app"
+
+      begin
+        require "spring-jruby/commands"
+      ensure
+        start_watcher
+      end
+
+      require Spring.application_root_path.join("config", "application")
+
+      # config/environments/test.rb will have config.cache_classes = true. However
+      # we want it to be false so that we can reload files. This is a hack to
+      # override the effect of config.cache_classes = true. We can then actually
+      # set config.cache_classes = false after loading the environment.
+      Rails::Application.initializer :initialize_dependency_mechanism, group: :all do
+        ActiveSupport::Dependencies.mechanism = :load
+      end
+
+      require Spring.application_root_path.join("config", "environment")
+
+      @original_cache_classes = Rails.application.config.cache_classes
+      Rails.application.config.cache_classes = false
+
+      disconnect_database
+
+      @preloaded = :success
+    rescue Exception => e
+      @preloaded = :failure
+      watcher.add e.backtrace.map { |line| line.match(/^(.*)\:\d+\:in /)[1] }
+      raise e unless initialized?
+    ensure
+      watcher.add loaded_application_features
+      watcher.add Spring.gemfile, "#{Spring.gemfile}.lock"
+
+      if defined?(Rails) && Rails.application
+        watcher.add Rails.application.paths["config/initializers"]
+        watcher.add Rails.application.paths["config/database"]
+        if secrets_path = Rails.application.paths["config/secrets"]
+          watcher.add secrets_path
+        end
+      end
+    end
+
+    def run
+      state :running
+      notify_manager_ready
+
+      loop do
+        IO.select [manager, @interrupt.first]
+
+        if terminating? || watcher_stale? || preload_failed?
+          exit
+        else
+          serve IOWrapper.recv_io(manager, UNIXSocket).to_io
+        end
+      end
+    end
+
+    def serve(client)
+      child_started = [false]
+      log "got client"
+      manager.puts
+
+      stdout, stderr, stdin = streams = receive_streams(client)
+      reopen_streams(streams)
+
+      preload unless preloaded?
+
+      args, env = JSON.load(client.read(client.gets.to_i)).values_at("args", "env")
+      command   = Spring.command(args.shift)
+
+      connect_database
+      setup command
+
+      if Rails.application.reloaders.any?(&:updated?)
+        ActionDispatch::Reloader.cleanup!
+        ActionDispatch::Reloader.prepare!
+      end
+
+      fork_child(client, streams, child_started) {
+        IGNORE_SIGNALS.each { |sig| trap(sig, "DEFAULT") }
+        trap("TERM", "DEFAULT")
+
+        ARGV.replace(args)
+        $0 = command.exec_name
+
+        # Delete all env vars which are unchanged from before spring started
+        original_env.each { |k, v| ENV.delete k if ENV[k] == v }
+
+        # Load in the current env vars, except those which *were* changed when spring started
+        env.each { |k, v| ENV[k] ||= v }
+
+        # requiring is faster, so if config.cache_classes was true in
+        # the environment's config file, then we can respect that from
+        # here on as we no longer need constant reloading.
+        if @original_cache_classes
+          ActiveSupport::Dependencies.mechanism = :require
+          Rails.application.config.cache_classes = true
+        end
+
+        connect_database
+        srand
+
+        invoke_after_fork_callbacks
+        shush_backtraces
+
+        before_command
+        command.call
+      }
+    rescue Exception => e
+      Kernel.exit if exiting? && e.is_a?(SystemExit)
+
+      log "exception: #{e}"
+      manager.puts unless child_started[0]
+
+      if streams && !e.is_a?(SystemExit)
+        print_exception(stderr || STDERR, e)
+        streams.each(&:close)
+      end
+
+      client.puts(1) if child_started[0]
+      client.close
+    end
+
+    def terminate
+      if exiting?
+        # Ensure that we do not ignore subsequent termination attempts
+        log "forced exit"
+        @waiting.each { |pid| Process.kill("TERM", pid) }
+        Kernel.exit
+      else
+        state! :terminating
+      end
+    end
+
+    def exit
+      state :exiting
+      manager.shutdown(:RDWR)
+      exit_if_finished
+      sleep
+    end
+
+    def exit_if_finished
+      @mutex.synchronize {
+        Kernel.exit if exiting? && @waiting.empty?
+      }
+    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.
+    def setup(command)
+      if command.setup
+        watcher.add loaded_application_features # loaded features may have changed
+      end
+    end
+
+    def invoke_after_fork_callbacks
+      Spring.after_fork_callbacks.each do |callback|
+        callback.call
+      end
+    end
+
+    def loaded_application_features
+      root = Spring.application_root_path.to_s
+      $LOADED_FEATURES.select { |f| f.start_with?(root) }
+    end
+
+    def disconnect_database
+      ActiveRecord::Base.remove_connection if active_record_configured?
+    end
+
+    def connect_database
+      ActiveRecord::Base.establish_connection if active_record_configured?
+    end
+
+    # This feels very naughty
+    def shush_backtraces
+      Kernel.module_eval do
+        old_raise = Kernel.method(:raise)
+        remove_method :raise
+        define_method :raise do |*args|
+          begin
+            old_raise.call(*args)
+          ensure
+            if $!
+              lib = File.expand_path("..", __FILE__)
+              $!.backtrace.reject! { |line| line.start_with?(lib) }
+            end
+          end
+        end
+        private :raise
+      end
+    end
+
+    def print_exception(stream, error)
+      first, rest = error.backtrace.first, error.backtrace.drop(1)
+      stream.puts("#{first}: #{error} (#{error.class})")
+      rest.each { |line| stream.puts("\tfrom #{line}") }
+    end
+
+    private
+
+    def active_record_configured?
+      defined?(ActiveRecord::Base) && ActiveRecord::Base.configurations.any?
+    end
+  end
+end