milhouse-spork 0.7.5.1 → 0.7.5.2

data/features/steps/rails_steps.rb

@@ -1,53 +1,53 @@
-Given /^I am in a fresh rails project named "(.+)"$/ do |folder_name|
-  @current_dir = SporkWorld::SANDBOX_DIR
-  version_argument = ENV['RAILS_VERSION'] ? "_#{ENV['RAILS_VERSION']}_" : nil
-  # run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
-  run([SporkWorld::RUBY_BINARY, '-I', Cucumber::LIBDIR, %x{which rails}.chomp, version_argument, folder_name].compact * " ")
-  @current_dir = File.join(File.join(SporkWorld::SANDBOX_DIR, folder_name))
-end
-
-
-Given "the application has a model, observer, route, and application helper" do
-  Given 'a file named "app/models/user.rb" with:',
-    """
-    class User < ActiveRecord::Base
-      $loaded_stuff << 'User'
-    end
-    """
-  Given 'a file named "app/models/user_observer.rb" with:',
-    """
-    class UserObserver < ActiveRecord::Observer
-      $loaded_stuff << 'UserObserver'
-    end
-    """
-  Given 'a file named "app/helpers/application_helper.rb" with:',
-    """
-    module ApplicationHelper
-      $loaded_stuff << 'ApplicationHelper'
-    end
-    """
-  Given 'the following code appears in "config/environment.rb" after /Rails::Initializer.run/:',
-    """
-      config.active_record.observers = :user_observer
-    """
-  Given 'the following code appears in "config/routes.rb" after /^end/:',
-    """
-      $loaded_stuff << 'config/routes.rb'
-    """
-  Given 'a file named "config/initializers/initialize_loaded_stuff.rb" with:',
-    """
-    $loaded_stuff ||= []
-    """
-  Given 'a file named "config/initializers/log_establish_connection_calls.rb" with:',
-    """
-    class ActiveRecord::Base
-      class << self
-        def establish_connection_with_load_logging(*args)
-          establish_connection_without_load_logging(*args)
-          $loaded_stuff << 'ActiveRecord::Base.establish_connection'
-        end
-        alias_method_chain :establish_connection, :load_logging
-      end
-    end
-    """
+Given /^I am in a fresh rails project named "(.+)"$/ do |folder_name|
+  @current_dir = SporkWorld::SANDBOX_DIR
+  version_argument = ENV['RAILS_VERSION'] ? "_#{ENV['RAILS_VERSION']}_" : nil
+  # run("#{SporkWorld::RUBY_BINARY} #{%x{which rails}.chomp} #{folder_name}")
+  run([SporkWorld::RUBY_BINARY, '-I', Cucumber::LIBDIR, %x{which rails}.chomp, version_argument, folder_name].compact * " ")
+  @current_dir = File.join(File.join(SporkWorld::SANDBOX_DIR, folder_name))
+end
+
+
+Given "the application has a model, observer, route, and application helper" do
+  Given 'a file named "app/models/user.rb" with:',
+    """
+    class User < ActiveRecord::Base
+      $loaded_stuff << 'User'
+    end
+    """
+  Given 'a file named "app/models/user_observer.rb" with:',
+    """
+    class UserObserver < ActiveRecord::Observer
+      $loaded_stuff << 'UserObserver'
+    end
+    """
+  Given 'a file named "app/helpers/application_helper.rb" with:',
+    """
+    module ApplicationHelper
+      $loaded_stuff << 'ApplicationHelper'
+    end
+    """
+  Given 'the following code appears in "config/environment.rb" after /Rails::Initializer.run/:',
+    """
+      config.active_record.observers = :user_observer
+    """
+  Given 'the following code appears in "config/routes.rb" after /^end/:',
+    """
+      $loaded_stuff << 'config/routes.rb'
+    """
+  Given 'a file named "config/initializers/initialize_loaded_stuff.rb" with:',
+    """
+    $loaded_stuff ||= []
+    """
+  Given 'a file named "config/initializers/log_establish_connection_calls.rb" with:',
+    """
+    class ActiveRecord::Base
+      class << self
+        def establish_connection_with_load_logging(*args)
+          establish_connection_without_load_logging(*args)
+          $loaded_stuff << 'ActiveRecord::Base.establish_connection'
+        end
+        alias_method_chain :establish_connection, :load_logging
+      end
+    end
+    """
 end

data/features/steps/sandbox_steps.rb

@@ -1,115 +1,115 @@
-Given /^I am in the directory "(.*)"$/ do |sandbox_dir_relative_path|
-  path = File.join(SporkWorld::SANDBOX_DIR, sandbox_dir_relative_path)
-  FileUtils.mkdir_p(path)
-  @current_dir = File.join(path)
-end
-
-Given /^a file named "([^\"]*)"$/ do |file_name|
-  create_file(file_name, '')
-end
-
-Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
-  create_file(file_name, file_content)
-end
-
-When /^the contents of "([^\"]*)" are changed to:$/ do |file_name, file_content|
-  create_file(file_name, file_content)
-end
-
-# the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
-Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
-  regex = Regexp.new(regex)
-  in_current_dir do
-    content_lines = File.read(file_name).split("\n")
-    0.upto(content_lines.length - 1) do |line_index|
-      if regex.match(content_lines[line_index])
-        content_lines.insert(line_index + 1, content)
-        break
-      end
-    end
-    File.open(file_name, 'wb') { |f| f << (content_lines * "\n") }
-  end
-end
-
-When /^I run (spork|spec|cucumber)(| .*)$/ do |command, args|
-  run(localized_command(command, args))
-end
-
-When /^I run this in the background: (spork|spec|cucumber)(| .*)$/ do |command, args|
-  @background_script = run_in_background(localized_command(command, args))
-end
-
-When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|
-  @spork_server = run_in_background("#{SporkWorld::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{SporkWorld::BINARY} #{spork_opts}")
-
-  output = ""
-  begin
-    status = Timeout::timeout(15) do
-      # Something that should be interrupted if it takes too much time...
-      while line = @spork_server.stderr.gets
-        output << line
-        puts line
-        break if line.include?("Spork is ready and listening")
-      end
-    end
-  rescue Timeout::Error
-    puts "I can't seem to launch Spork properly.  Output was:\n#{output}"
-    true.should == false
-  end
-end
-
-Then /^the spork window should output a line containing "(.+)"/ do |expected|
-  output = ""
-  begin
-    status = Timeout::timeout(5) do
-      # Something that should be interrupted if it takes too much time...
-      while line = @spork_server.stdout.gets
-        output << line
-        puts line
-        break if output.include?(expected)
-      end
-    end
-  rescue Timeout::Error
-    output.should include(expected)
-  end
-end
-
-When /^I type this in the spork window: "(.+)"/ do |line|
-  @spork_server.stdin.puts(line)
-  @spork_server.stdin.flush
-end
-
-
-Then /^the file "([^\"]*)" should include "([^\"]*)"$/ do |filename, content|
-  in_current_dir do
-    File.read(filename).should include(content)
-  end
-end
-
-Then /^the (error output|output) should contain$/ do |which, text|
-  (which == "error output" ? last_stderr : last_stdout).should include(text)
-end
-
-Then /^the (error output|output) should contain "(.+)"$/ do |which, text|
-  (which == "error output" ? last_stderr : last_stdout).should include(text)
-end
-
-Then /^the (error output|output) should match \/(.+)\/$/ do |which, regex|
-  (which == "error output" ? last_stderr : last_stdout).should match(Regexp.new(regex))
-end
-
-Then /^the (error output|output) should not contain$/ do |which, text|
-  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
-end
-
-Then /^the (error output|output) should not contain "(.+)"$/ do |which, text|
-  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
-end
-
-Then /^the (error output|output) should be empty$/ do |which|
-  (which == "error output" ? last_stderr : last_stdout).should == ""
-end
-
-Then /^the (error output|output) should be$/ do |which, text|
-  (which == "error output" ? last_stderr : last_stdout).should == text
-end
+Given /^I am in the directory "(.*)"$/ do |sandbox_dir_relative_path|
+  path = File.join(SporkWorld::SANDBOX_DIR, sandbox_dir_relative_path)
+  FileUtils.mkdir_p(path)
+  @current_dir = File.join(path)
+end
+
+Given /^a file named "([^\"]*)"$/ do |file_name|
+  create_file(file_name, '')
+end
+
+Given /^a file named "([^\"]*)" with:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+When /^the contents of "([^\"]*)" are changed to:$/ do |file_name, file_content|
+  create_file(file_name, file_content)
+end
+
+# the following code appears in "config/environment.rb" after /Rails::Initializer.run/:
+Given /^the following code appears in "([^\"]*)" after \/([^\\\/]*)\/:$/ do |file_name, regex, content|
+  regex = Regexp.new(regex)
+  in_current_dir do
+    content_lines = File.read(file_name).split("\n")
+    0.upto(content_lines.length - 1) do |line_index|
+      if regex.match(content_lines[line_index])
+        content_lines.insert(line_index + 1, content)
+        break
+      end
+    end
+    File.open(file_name, 'wb') { |f| f << (content_lines * "\n") }
+  end
+end
+
+When /^I run (spork|spec|cucumber)(| .*)$/ do |command, args|
+  run(localized_command(command, args))
+end
+
+When /^I run this in the background: (spork|spec|cucumber)(| .*)$/ do |command, args|
+  @background_script = run_in_background(localized_command(command, args))
+end
+
+When /^I fire up a spork instance with "spork(.*)"$/ do |spork_opts|
+  @spork_server = run_in_background("#{SporkWorld::RUBY_BINARY} -I #{Cucumber::LIBDIR} #{SporkWorld::BINARY} #{spork_opts}")
+
+  output = ""
+  begin
+    status = Timeout::timeout(15) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @spork_server.stderr.gets
+        output << line
+        puts line
+        break if line.include?("Spork is ready and listening")
+      end
+    end
+  rescue Timeout::Error
+    puts "I can't seem to launch Spork properly.  Output was:\n#{output}"
+    true.should == false
+  end
+end
+
+Then /^the spork window should output a line containing "(.+)"/ do |expected|
+  output = ""
+  begin
+    status = Timeout::timeout(5) do
+      # Something that should be interrupted if it takes too much time...
+      while line = @spork_server.stdout.gets
+        output << line
+        puts line
+        break if output.include?(expected)
+      end
+    end
+  rescue Timeout::Error
+    output.should include(expected)
+  end
+end
+
+When /^I type this in the spork window: "(.+)"/ do |line|
+  @spork_server.stdin.puts(line)
+  @spork_server.stdin.flush
+end
+
+
+Then /^the file "([^\"]*)" should include "([^\"]*)"$/ do |filename, content|
+  in_current_dir do
+    File.read(filename).should include(content)
+  end
+end
+
+Then /^the (error output|output) should contain$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should include(text)
+end
+
+Then /^the (error output|output) should contain "(.+)"$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should include(text)
+end
+
+Then /^the (error output|output) should match \/(.+)\/$/ do |which, regex|
+  (which == "error output" ? last_stderr : last_stdout).should match(Regexp.new(regex))
+end
+
+Then /^the (error output|output) should not contain$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
+end
+
+Then /^the (error output|output) should not contain "(.+)"$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should_not include(text)
+end
+
+Then /^the (error output|output) should be empty$/ do |which|
+  (which == "error output" ? last_stderr : last_stdout).should == ""
+end
+
+Then /^the (error output|output) should be$/ do |which, text|
+  (which == "error output" ? last_stderr : last_stdout).should == text
+end

data/features/support/background_job.rb

@@ -1,63 +1,63 @@
-class BackgroundJob
-  attr_reader :stdin, :stdout, :stderr, :pid
-  def initialize(pid, stdin, stdout, stderr)
-    @pid, @stdin, @stdout, @stderr = pid, stdin, stdout, stderr
-    ObjectSpace.define_finalizer(self) { kill }
-  end
-
-  def self.run(command)
-    command = sanitize_params(command) if command.is_a?(Array)
-    child_stdin, parent_stdin = IO::pipe
-    parent_stdout, child_stdout = IO::pipe
-    parent_stderr, child_stderr = IO::pipe
-
-    pid = Kernel.fork do
-      [parent_stdin, parent_stdout, parent_stderr].each { |io| io.close }
-
-      STDIN.reopen(child_stdin)
-      STDOUT.reopen(child_stdout)
-      STDERR.reopen(child_stderr)
-
-      [child_stdin, child_stdout, child_stderr].each { |io| io.close }
-
-      exec command
-    end
-
-    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
-    parent_stdin.sync = true
-
-    new(pid, parent_stdin, parent_stdout, parent_stderr)
-  end
-
-  def self.sanitize_params(params)
-    params.map { |p| p.gsub(' ', '\ ') }.join(" ")
-  end
-
-  def kill(signal = 'TERM')
-    if running?
-      Process.kill(Signal.list[signal], @pid)
-      true
-    end
-  end
-
-  def interrupt
-    kill('INT')
-  end
-
-  def running?
-    return false unless @pid
-    Process.getpgid(@pid)
-    true
-  rescue Errno::ESRCH
-    false
-  end
-
-  def wait(timeout = 1000)
-    Timeout.timeout(timeout) do
-      Process.wait(@pid)
-    end
-    true
-  rescue Timeout::Error
-    false
-  end
-end
+class BackgroundJob
+  attr_reader :stdin, :stdout, :stderr, :pid
+  def initialize(pid, stdin, stdout, stderr)
+    @pid, @stdin, @stdout, @stderr = pid, stdin, stdout, stderr
+    ObjectSpace.define_finalizer(self) { kill }
+  end
+
+  def self.run(command)
+    command = sanitize_params(command) if command.is_a?(Array)
+    child_stdin, parent_stdin = IO::pipe
+    parent_stdout, child_stdout = IO::pipe
+    parent_stderr, child_stderr = IO::pipe
+
+    pid = Kernel.fork do
+      [parent_stdin, parent_stdout, parent_stderr].each { |io| io.close }
+
+      STDIN.reopen(child_stdin)
+      STDOUT.reopen(child_stdout)
+      STDERR.reopen(child_stderr)
+
+      [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+
+      exec command
+    end
+
+    [child_stdin, child_stdout, child_stderr].each { |io| io.close }
+    parent_stdin.sync = true
+
+    new(pid, parent_stdin, parent_stdout, parent_stderr)
+  end
+
+  def self.sanitize_params(params)
+    params.map { |p| p.gsub(' ', '\ ') }.join(" ")
+  end
+
+  def kill(signal = 'TERM')
+    if running?
+      Process.kill(Signal.list[signal], @pid)
+      true
+    end
+  end
+
+  def interrupt
+    kill('INT')
+  end
+
+  def running?
+    return false unless @pid
+    Process.getpgid(@pid)
+    true
+  rescue Errno::ESRCH
+    false
+  end
+
+  def wait(timeout = 1000)
+    Timeout.timeout(timeout) do
+      Process.wait(@pid)
+    end
+    true
+  rescue Timeout::Error
+    false
+  end
+end