milhouse-spork 0.7.5.1 → 0.7.5.2

data/lib/spork/test_framework.rb

@@ -1,167 +1,167 @@
-class Spork::TestFramework
-  LOAD_PREFERENCE = ['RSpec', 'Cucumber']
-  BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
-
-  @@supported_test_frameworks = []
-  attr_reader :stdout, :stderr
-
-  class FactoryException < Exception; end
-
-  class NoFrameworksAvailable < FactoryException
-    def message
-      "I can't find any testing frameworks to use.  Are you running me from a project directory?"
-    end
-  end
-
-  class FrameworkNotAvailable < FactoryException
-    def initialize(framework)
-      @framework = framework
-    end
-
-    def message
-      "I can't find the file #{@framework.helper_file} for the #{@framework.short_name} testing framework.\nAre you running me from the project directory?"
-    end
-  end
-
-  class NoFrameworkMatched < FactoryException
-    def initialize(beginning_with)
-      @beginning_with = beginning_with
-    end
-
-    def message
-      "Couldn't find a supported test framework that begins with '#{@beginning_with}'"
-    end
-  end
-
-  def initialize(stdout = STDOUT, stderr = STDERR)
-    @stdout, @stderr = stdout, stderr
-  end
-
-  def self.factory(output = STDOUT, error = STDERR, beginning_with = nil)
-    if beginning_with
-      @klass = supported_test_frameworks(beginning_with).first
-      raise(NoFrameworkMatched.new(beginning_with)) if @klass.nil?
-      raise(FrameworkNotAvailable.new(@klass)) unless @klass.available?
-    else
-      @klass = available_test_frameworks.first
-      raise(NoFrameworksAvailable.new) unless @klass
-    end
-    @klass.new(output, error)
-  end
-
-  def self.helper_file
-    self::HELPER_FILE
-  end
-
-  def self.default_port
-    (ENV["#{short_name.upcase}_DRB"] || self::DEFAULT_PORT).to_i
-  end
-
-  def self.short_name
-    self.name.gsub('Spork::TestFramework::', '')
-  end
-
-  # Returns a list of all testing servers that have detected their testing framework being used in the project.
-  def self.available_test_frameworks
-    supported_test_frameworks.select { |s| s.available? }
-  end
-
-  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
-  def self.supported_test_frameworks(starting_with = nil)
-    @@supported_test_frameworks.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
-    return @@supported_test_frameworks if starting_with.nil?
-    @@supported_test_frameworks.select do |s|
-      s.short_name.match(/^#{Regexp.escape(starting_with)}/i)
-    end
-  end
-
-  def short_name
-    self.class.short_name
-  end
-
-  def helper_file
-    self.class.helper_file
-  end
-
-  # Detects if the test helper has been bootstrapped.
-  def bootstrapped?
-    File.read(helper_file).include?("Spork.prefork")
-  end
-
-  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
-  def bootstrap
-    if bootstrapped?
-      stderr.puts "Already bootstrapped!"
-      return
-    end
-    stderr.puts "Bootstrapping #{helper_file}."
-    contents = File.read(helper_file)
-    bootstrap_code = File.read(BOOTSTRAP_FILE)
-    File.open(helper_file, "wb") do |f|
-      f.puts bootstrap_code
-      f.puts contents
-    end
-
-    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
-    true
-  end
-
-  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
-  def self.available?
-    File.exist?(helper_file)
-  end
-
-  # Used to specify
-  def self.load_preference_index
-    LOAD_PREFERENCE.index(short_name) || LOAD_PREFERENCE.length
-  end
-
-  def preload
-    Spork.exec_prefork do
-      unless bootstrapped?
-        stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
-        stderr.flush
-
-        if framework.bootstrap_required?
-          stderr.puts "I can't do anything for you by default for the framework your using: #{framework.short_name}.\nYou must bootstrap #{helper_file} to continue."
-          stderr.flush
-          return false
-        else
-          load(framework.entry_point)
-        end
-      end
-
-      framework.preload do
-        if bootstrapped?
-          stderr.puts "Loading Spork.prefork block..."
-          stderr.flush
-          load(helper_file)
-        end
-      end
-    end
-    true
-  end
-
-  def run_tests(argv, stderr, stdout)
-    raise NotImplementedError
-  end
-
-  def entry_point
-    bootstrapped? ? helper_file : framework.entry_point
-  end
-
-  def default_port
-    self.class.default_port
-  end
-
-  protected
-    def self.inherited(subclass)
-      @@supported_test_frameworks << subclass
-    end
-
-    def framework
-      @framework ||= Spork::AppFramework.detect_framework
-    end
-end
-
-Spork.detect_and_require('spork/test_framework/*.rb')
+class Spork::TestFramework
+  LOAD_PREFERENCE = ['RSpec', 'Cucumber']
+  BOOTSTRAP_FILE = File.dirname(__FILE__) + "/../../assets/bootstrap.rb"
+
+  @@supported_test_frameworks = []
+  attr_reader :stdout, :stderr
+
+  class FactoryException < Exception; end
+
+  class NoFrameworksAvailable < FactoryException
+    def message
+      "I can't find any testing frameworks to use.  Are you running me from a project directory?"
+    end
+  end
+
+  class FrameworkNotAvailable < FactoryException
+    def initialize(framework)
+      @framework = framework
+    end
+
+    def message
+      "I can't find the file #{@framework.helper_file} for the #{@framework.short_name} testing framework.\nAre you running me from the project directory?"
+    end
+  end
+
+  class NoFrameworkMatched < FactoryException
+    def initialize(beginning_with)
+      @beginning_with = beginning_with
+    end
+
+    def message
+      "Couldn't find a supported test framework that begins with '#{@beginning_with}'"
+    end
+  end
+
+  def initialize(stdout = STDOUT, stderr = STDERR)
+    @stdout, @stderr = stdout, stderr
+  end
+
+  def self.factory(output = STDOUT, error = STDERR, beginning_with = nil)
+    if beginning_with
+      @klass = supported_test_frameworks(beginning_with).first
+      raise(NoFrameworkMatched.new(beginning_with)) if @klass.nil?
+      raise(FrameworkNotAvailable.new(@klass)) unless @klass.available?
+    else
+      @klass = available_test_frameworks.first
+      raise(NoFrameworksAvailable.new) unless @klass
+    end
+    @klass.new(output, error)
+  end
+
+  def self.helper_file
+    self::HELPER_FILE
+  end
+
+  def self.default_port
+    (ENV["#{short_name.upcase}_DRB"] || self::DEFAULT_PORT).to_i
+  end
+
+  def self.short_name
+    self.name.gsub('Spork::TestFramework::', '')
+  end
+
+  # Returns a list of all testing servers that have detected their testing framework being used in the project.
+  def self.available_test_frameworks
+    supported_test_frameworks.select { |s| s.available? }
+  end
+
+  # Returns a list of all servers that have been implemented (it keeps track of them automatically via Class.inherited)
+  def self.supported_test_frameworks(starting_with = nil)
+    @@supported_test_frameworks.sort! { |a,b| a.load_preference_index <=> b.load_preference_index }
+    return @@supported_test_frameworks if starting_with.nil?
+    @@supported_test_frameworks.select do |s|
+      s.short_name.match(/^#{Regexp.escape(starting_with)}/i)
+    end
+  end
+
+  def short_name
+    self.class.short_name
+  end
+
+  def helper_file
+    self.class.helper_file
+  end
+
+  # Detects if the test helper has been bootstrapped.
+  def bootstrapped?
+    File.read(helper_file).include?("Spork.prefork")
+  end
+
+  # Bootstraps the current test helper file by prepending a Spork.prefork and Spork.each_run block at the beginning.
+  def bootstrap
+    if bootstrapped?
+      stderr.puts "Already bootstrapped!"
+      return
+    end
+    stderr.puts "Bootstrapping #{helper_file}."
+    contents = File.read(helper_file)
+    bootstrap_code = File.read(BOOTSTRAP_FILE)
+    File.open(helper_file, "wb") do |f|
+      f.puts bootstrap_code
+      f.puts contents
+    end
+
+    stderr.puts "Done. Edit #{helper_file} now with your favorite text editor and follow the instructions."
+    true
+  end
+
+  # Returns true if the testing frameworks helper file exists.  Override if this is not sufficient to detect your testing framework.
+  def self.available?
+    File.exist?(helper_file)
+  end
+
+  # Used to specify
+  def self.load_preference_index
+    LOAD_PREFERENCE.index(short_name) || LOAD_PREFERENCE.length
+  end
+
+  def preload
+    Spork.exec_prefork do
+      unless bootstrapped?
+        stderr.puts "#{helper_file} has not been bootstrapped.  Run spork --bootstrap to do so."
+        stderr.flush
+
+        if framework.bootstrap_required?
+          stderr.puts "I can't do anything for you by default for the framework your using: #{framework.short_name}.\nYou must bootstrap #{helper_file} to continue."
+          stderr.flush
+          return false
+        else
+          load(framework.entry_point)
+        end
+      end
+
+      framework.preload do
+        if bootstrapped?
+          stderr.puts "Loading Spork.prefork block..."
+          stderr.flush
+          load(helper_file)
+        end
+      end
+    end
+    true
+  end
+
+  def run_tests(argv, stderr, stdout)
+    raise NotImplementedError
+  end
+
+  def entry_point
+    bootstrapped? ? helper_file : framework.entry_point
+  end
+
+  def default_port
+    self.class.default_port
+  end
+
+  protected
+    def self.inherited(subclass)
+      @@supported_test_frameworks << subclass
+    end
+
+    def framework
+      @framework ||= Spork::AppFramework.detect_framework
+    end
+end
+
+Spork.detect_and_require('spork/test_framework/*.rb')

data/lib/spork.rb

@@ -1,126 +1,126 @@
-$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
-require 'pathname'
-module Spork
-  BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
-  LIBDIR = Pathname.new(File.expand_path(File.dirname(__FILE__)))
-
-  autoload :Server,        (LIBDIR + 'spork/server').to_s
-  autoload :TestFramework, (LIBDIR + 'spork/test_framework').to_s
-  autoload :AppFramework,  (LIBDIR + 'spork/app_framework').to_s
-  autoload :RunStrategy,   (LIBDIR + 'spork/run_strategy').to_s
-  autoload :Runner,        (LIBDIR + 'spork/runner').to_s
-  autoload :Forker,        (LIBDIR + 'spork/forker').to_s
-  autoload :Diagnoser,     (LIBDIR + 'spork/diagnoser').to_s
-
-  class << self
-    # Run a block, during prefork mode.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
-    #
-    # == Parameters
-    #
-    # * +prevent_double_run+ - Pass false to disable double run prevention
-    def prefork(prevent_double_run = true, &block)
-      return if prevent_double_run && already_ran?(caller.first)
-      yield
-    end
-    
-    # Run a block AFTER the fork occurs.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
-    #
-    # == Parameters
-    #
-    # * +prevent_double_run+ - Pass false to disable double run prevention
-    def each_run(prevent_double_run = true, &block)
-      return if prevent_double_run && already_ran?(caller.first)
-      if @state == :using_spork
-        each_run_procs << block
-      else
-        yield
-      end
-    end
-    
-    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
-    def using_spork!
-      @state = :using_spork
-    end
-    
-    def using_spork?
-      @state == :using_spork
-    end
-
-    # Used by the server.  Returns the current state of Spork.
-    def state
-      @state ||= :not_using_spork
-    end
-    
-    # Used by the server.  Called when loading the prefork blocks of the code.
-    def exec_prefork(&block)
-      using_spork!
-      yield
-    end
-    
-    # Used by the server.  Called to run all of the prefork blocks.
-    def exec_each_run(&block)
-      each_run_procs.each { |p| p.call }
-      each_run_procs.clear
-      yield if block_given?
-    end
-    
-    # Traps an instance method of a class (or module) so any calls to it don't actually run until Spork.exec_each_run
-    def trap_method(klass, method_name)
-      method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :spork)
-      
-      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
-        alias :#{method_name_without_spork} :#{method_name} unless method_defined?(:#{method_name_without_spork}) 
-        def #{method_name}(*args)
-          Spork.each_run(false) do
-            #{method_name_without_spork}(*args)
-          end
-        end
-      EOF
-    end
-    
-    # Same as trap_method, but for class methods instead
-    def trap_class_method(klass, method_name)
-      trap_method((class << klass; self; end), method_name)
-    end
-    
-    def detect_and_require(subfolder)
-      ([LIBDIR.to_s] + other_spork_gem_load_paths).uniq.each do |gem_path|
-        Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
-      end
-    end
-
-    def other_spork_gem_load_paths
-      @other_spork_gem_load_paths ||= (
-        Gem.latest_load_paths.grep(/spork/).select do |g|
-          not g.match(%r{/spork-[0-9\-.]+/lib}) # don't include other versions of spork
-        end
-      )
-    end
-
-    private
-      def alias_method_names(method_name, feature)
-        /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)
-        ["#{$1}_without_spork#{$2}", "#{$1}_with_spork#{$2}"]
-      end
-      
-      def already_ran
-        @already_ran ||= []
-      end
-      
-      def expanded_caller(caller_line)
-        file, line = caller_line.split(":")
-        line.gsub(/:.+/, '')
-        File.expand_path(file, Dir.pwd) + ":" + line
-      end
-      
-      def already_ran?(caller_script_and_line)
-        return true if already_ran.include?(expanded_caller(caller_script_and_line))
-        already_ran << expanded_caller(caller_script_and_line)
-        false
-      end
-      
-      def each_run_procs
-        @each_run_procs ||= []
-      end
-  end
-end
+$LOAD_PATH.unshift(File.expand_path(File.dirname(__FILE__))) unless $LOAD_PATH.include?(File.expand_path(File.dirname(__FILE__)))
+require 'pathname'
+module Spork
+  BINARY = File.expand_path(File.dirname(__FILE__) + '/../bin/spork')
+  LIBDIR = Pathname.new(File.expand_path(File.dirname(__FILE__)))
+
+  autoload :Server,        (LIBDIR + 'spork/server').to_s
+  autoload :TestFramework, (LIBDIR + 'spork/test_framework').to_s
+  autoload :AppFramework,  (LIBDIR + 'spork/app_framework').to_s
+  autoload :RunStrategy,   (LIBDIR + 'spork/run_strategy').to_s
+  autoload :Runner,        (LIBDIR + 'spork/runner').to_s
+  autoload :Forker,        (LIBDIR + 'spork/forker').to_s
+  autoload :Diagnoser,     (LIBDIR + 'spork/diagnoser').to_s
+
+  class << self
+    # Run a block, during prefork mode.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def prefork(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      yield
+    end
+    
+    # Run a block AFTER the fork occurs.  By default, if prefork is called twice in the same file and line number, the supplied block will only be ran once.
+    #
+    # == Parameters
+    #
+    # * +prevent_double_run+ - Pass false to disable double run prevention
+    def each_run(prevent_double_run = true, &block)
+      return if prevent_double_run && already_ran?(caller.first)
+      if @state == :using_spork
+        each_run_procs << block
+      else
+        yield
+      end
+    end
+    
+    # Used by the server. Sets the state to activate spork. Otherwise, prefork and each_run are run in passive mode, allowing specs without a Spork server.
+    def using_spork!
+      @state = :using_spork
+    end
+    
+    def using_spork?
+      @state == :using_spork
+    end
+
+    # Used by the server.  Returns the current state of Spork.
+    def state
+      @state ||= :not_using_spork
+    end
+    
+    # Used by the server.  Called when loading the prefork blocks of the code.
+    def exec_prefork(&block)
+      using_spork!
+      yield
+    end
+    
+    # Used by the server.  Called to run all of the prefork blocks.
+    def exec_each_run(&block)
+      each_run_procs.each { |p| p.call }
+      each_run_procs.clear
+      yield if block_given?
+    end
+    
+    # Traps an instance method of a class (or module) so any calls to it don't actually run until Spork.exec_each_run
+    def trap_method(klass, method_name)
+      method_name_without_spork, method_name_with_spork = alias_method_names(method_name, :spork)
+      
+      klass.class_eval <<-EOF, __FILE__, __LINE__ + 1
+        alias :#{method_name_without_spork} :#{method_name} unless method_defined?(:#{method_name_without_spork}) 
+        def #{method_name}(*args)
+          Spork.each_run(false) do
+            #{method_name_without_spork}(*args)
+          end
+        end
+      EOF
+    end
+    
+    # Same as trap_method, but for class methods instead
+    def trap_class_method(klass, method_name)
+      trap_method((class << klass; self; end), method_name)
+    end
+    
+    def detect_and_require(subfolder)
+      ([LIBDIR.to_s] + other_spork_gem_load_paths).uniq.each do |gem_path|
+        Dir.glob(File.join(gem_path, subfolder)).each { |file| require file }
+      end
+    end
+
+    def other_spork_gem_load_paths
+      @other_spork_gem_load_paths ||= (
+        Gem.latest_load_paths.grep(/spork/).select do |g|
+          not g.match(%r{/spork-[0-9\-.]+/lib}) # don't include other versions of spork
+        end
+      )
+    end
+
+    private
+      def alias_method_names(method_name, feature)
+        /^(.+?)([\?\!]{0,1})$/.match(method_name.to_s)
+        ["#{$1}_without_spork#{$2}", "#{$1}_with_spork#{$2}"]
+      end
+      
+      def already_ran
+        @already_ran ||= []
+      end
+      
+      def expanded_caller(caller_line)
+        file, line = caller_line.split(":")
+        line.gsub(/:.+/, '')
+        File.expand_path(file, Dir.pwd) + ":" + line
+      end
+      
+      def already_ran?(caller_script_and_line)
+        return true if already_ran.include?(expanded_caller(caller_script_and_line))
+        already_ran << expanded_caller(caller_script_and_line)
+        false
+      end
+      
+      def each_run_procs
+        @each_run_procs ||= []
+      end
+  end
+end