rack-unreloader 1.8.0 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6fefe4d57aa2ea927929699e2a6aba2e8979cea284b0784fee379404b6f1726
-  data.tar.gz: 3aa21b88447194616e29d1ea2cf1181f102f5d58e6a29f4a11696a83d826a506
+  metadata.gz: 01a3ddc58ad8308cd61dd10991e7478f546bd7d1bc2fc4bb88203b4a37d7b335
+  data.tar.gz: ceff468f0b2755347859e3d2a408087379a056975e00c73fe35adc5854c3cbc0
 SHA512:
-  metadata.gz: 6a5fbca1692b66ab4daf1f9b1677b15fb704d28bb972b26fdc15d78918fa37bed04657177438ff2351ba8c60a10105f7e138d869a4ab37fbd9e4143188c5685d
-  data.tar.gz: 12d9b2d24730e1f41da6089e5995c219af4b636755738405d1404e0be3f4044c8f935bd073ba53d92cada170761f79bfea82235c5b58d9ca6bc1dac1ee1b647f
+  metadata.gz: 71c0dc1e1ebfcad459d8bf6d1533200ad071f857fe2b53fb7f26af1e079169eca3835b2b1eee4a39d572244bf3208bd51718120f7e89f4dcd5b646cbed6195ca
+  data.tar.gz: d9e9ab98a9b36a44d0d819f0142a1c9c49a21598a390da18c7cee48199cd365a0acac7c4fd95955e49b3f18a7ef8e0fe75bfa138312e3b2d16f57ebc7574731f

data/CHANGELOG

@@ -1,3 +1,17 @@
+= 2.1.0 (2023-01-18)
+
+* Add reload? and autoload? methods for determining what mode the unreloader is operating in (jeremyevans)
+
+* Support :autoload option and autoload method for autoloading files and directories (jeremyevans)
+
+= 2.0.0 (2022-06-23)
+
+* Fix TypeError being raised when requiring a file results in an error (jeremyevans)
+
+* Drop Unreloader#strip_path_prefix (jeremyevans)
+
+* Drop Ruby 1.8 support (jeremyevans)
+
 = 1.8.0 (2021-10-15)
 
 * Avoid warnings in verbose warning mode on Ruby 3+ (jeremyevans)

data/MIT-LICENSE

@@ -1,4 +1,4 @@
-Copyright (c) 2014-2021 Jeremy Evans
+Copyright (c) 2014-2023 Jeremy Evans
 Copyright (c) 2011 Padrino
 
 Permission is hereby granted, free of charge, to any person obtaining

data/README.rdoc

@@ -195,7 +195,7 @@ class.
 
 == Requiring
 
-Rack::Unreloader#require is a little different than require in that it takes
+Rack::Unreloader#require is a little different than Kernel#require in that it takes
 a file glob, not a normal require path.  For that reason, you must specify
 the extension when requiring the file, and it will only look in the current
 directory by default:
@@ -253,17 +253,44 @@ decide that instead of specifying the constants, ObjectSpace should be used to
 automatically determine the constants loaded. You can specify this by having the
 block return the :ObjectSpace symbol.
 
-== chroot Support
+=== Autoload
 
-+Rack::Unreloader#strip_path_prefix+ exists for supporting reloading in
-chroot environments, where you chroot an application after it has been fully
-loaded, but still want to pick up changes to files inside the chroot. Example:
+To further speed things up in development mode, or when only running a subset of
+tests, it can be helpful to autoload files instead of require them, so that if
+the related constants are not accessed, you don't need to pay the cost of loading
+the related files.  To enable autoloading, pass the +:autoload+ option when
+creating the reloader:
 
-  Unreloader.strip_path_prefix(Dir.pwd)
-  Dir.chroot(Dir.pwd)
+  Unreloader = Rack::Unreloader.new(autoload: true){App}
 
-Note that Unreloader.strip_path_prefix also strips the path prefix from
-$LOADED_FEATURES, as that is necessary for correct operation.
+Then, you can call +autoload+ instead of +require+:
+
+  Unreloader.autoload('models'){|f| File.basename(f).sub(/\.rb\z/, '').capitalize}
+
+This will monitor the models directory for files, setting up autoloads for each
+file.  After the file has been loaded, normal reloading will happen for the
+file. Note that for +autoload+, a block is required because the constant names
+are needed before loading the file to setup the autoload.
+
+If the <tt>reload: false</tt> option is given when creating the reloader,
+autoloads will still be setup by +autoload+, but no reloading will happen. This
+can be useful when testing subsets of an application.  When testing subsets of
+an application, you don't need reloading, but you can benefit from autoloading,
+so parts of the application you are not testing are not loaded.
+
+If you do not pass the +:autoload+ option when creating the reloader, then calls
+to +autoload+ will implicitly be transformed to calls to +require+.  This makes
+it possible to use the same +autoload+ call in all cases, and handle four
+separate scenarios:
+
+1. Autoload then reload: Fast development mode startup, loading the minimum
+   number of files, but reloading if those files are changed
+2. Autoload without reload: Useful for faster testing of a subset of an
+   application, so the untested subsets is not loaded.
+3. Require then reload: Slower development mode startup, but have entire
+   application loaded before accepting requests
+4. Require without reload: Normal production/testing mode with nothing autoloaded
+   or reloaded
 
 == Usage Outside Rack
 
@@ -296,11 +323,9 @@ environment anytime there are any changes) are going to be more robust than
 this approach, but probably slower.  Be aware that you are trading robustness
 for speed when using this library.
 
-== Implementation Support
+== Ruby Version Support
 
-Rack::Unreloader works correctly on Ruby 1.8.7+, JRuby 9.1+, and Rubinius.  It
-also works on older versions of JRuby if you use a proc to specify the constants
-to unload.
+Rack::Unreloader works correctly on Ruby 1.9.2+ and JRuby 9.1+.
 
 == License
 

data/lib/rack/unreloader/autoload_reloader.rb

@@ -0,0 +1,89 @@
+require_relative 'reloader'
+
+module Rack
+  class Unreloader
+    class AutoloadReloader < Reloader
+      def initialize(opts={})
+        super
+
+        # Files that autoloads have been setup for, but have not yet been loaded.
+        # Hash with realpath keys and values that are arrays with the
+        # a block that will return constant name strings that will autoload the 
+        # file, the modified time the file, and the delete hook.
+        @autoload_files = {}
+
+        # Directories where new files will be setup for autoloading.
+        # Uses same format as @monitor_dirs.
+        @autoload_dirs = {}
+      end
+
+      def autoload_dependencies(paths, opts={}, &block)
+        delete_hook = opts[:delete_hook]
+
+        Unreloader.expand_paths(paths).each do |file|
+          if File.directory?(file)
+            @autoload_dirs[file] = [nil, [], block, delete_hook]
+            check_autoload_dir(file)
+          else
+            # Comparisons against $LOADED_FEATURES need realpaths
+            @autoload_files[File.realpath(file)] = [block, modified_at(file), delete_hook]
+            Unreloader.autoload_constants(yield(file), file, @logger)
+          end
+        end
+      end
+
+      def remove_autoload(file, strings)
+        strings = Array(strings)
+        log("Removing autoload for #{file}: #{strings.join(" ")}") unless strings.empty?
+        strings.each do |s|
+          obj, mod = Unreloader.split_autoload(s)
+          # Assume that if the autoload string was valid to create the
+          # autoload, it is still valid when removing the autoload.
+          obj.send(:remove_const, mod)
+        end
+      end
+
+      def check_autoload_dir(dir)
+        subdir_times, files, block, delete_hook = md = @autoload_dirs[dir]
+        return if subdir_times && subdir_times.all?{|subdir, time| File.directory?(subdir) && modified_at(subdir) == time}
+        md[0] = subdir_times(dir)
+
+        cur_files = Unreloader.ruby_files(dir)
+        return if files == cur_files
+
+        removed_files = files - cur_files
+        new_files = cur_files - files
+
+        # Removed files that were never required should have the constant removed
+        # so that accesses to the constant do not attempt to autoload a file that
+        # no longer exists.
+        removed_files.each do |file|
+          remove_autoload(file, block.call(file)) unless @monitor_files[file]
+        end
+
+        # New files not yet loaded should have autoloads added for them.
+        autoload_dependencies(new_files, :delete_hook=>delete_hook, &block) unless new_files.empty?
+
+        files.replace(cur_files)
+      end
+
+      def reload!
+        (@autoload_files.keys & $LOADED_FEATURES).each do |file|
+          # Files setup for autoloads were autoloaded, move metadata to locations
+          # used for required files.
+          log("Autoloaded file required, setting up reloading: #{file}")
+          block, *metadata = @autoload_files.delete(file)
+          @constants_defined[file] = block
+          @monitor_files[file] = metadata
+          @files[file] = {:features=>Set.new, :constants=>Array(block.call(file))}
+        end
+
+        @autoload_dirs.each_key do |dir|
+          check_autoload_dir(dir)
+        end
+
+        super
+      end
+    end
+  end
+end

data/lib/rack/unreloader/reloader.rb

@@ -5,12 +5,6 @@ module Rack
     class Reloader
       File = ::File
 
-      # Regexp for valid constant names, to prevent code execution.
-      VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
-
-      # Options hash to force loading of files even if they haven't changed.
-      FORCE = {:force=>true}.freeze
-
       # Setup the reloader.  Supports :logger and :subclasses options, see
       # Rack::Unloader.new for details.
       def initialize(opts={})
@@ -55,47 +49,6 @@ module Rack
         @skip_reload = []
       end
 
-      # Strip the given path prefix from the internal data structures.
-      def strip_path_prefix(path_prefix)
-        empty = ''.freeze
-
-        # Strip the path prefix from $LOADED_FEATURES, otherwise the reloading won't work.
-        # Hopefully a future version of ruby will do this automatically when chrooting.
-        $LOADED_FEATURES.map!{|s| s.sub(path_prefix, empty)}
-
-        fix_path = lambda do |s|
-          s.sub(path_prefix, empty)
-        end
-
-        [@dependency_order, @skip_reload].each do |a|
-          a.map!(&fix_path)
-        end
-
-        [@files, @old_entries].each do |hash|
-          hash.each do |k,h|
-            h[:features].map!(&fix_path)
-          end
-        end
-        
-        @monitor_dirs.each_value do |a|
-          a[1].map!(&fix_path)
-        end
-
-        @dependencies.each_value do |a|
-          a.map!(&fix_path)
-        end
-
-        [@files, @old_entries, @monitor_files, @monitor_dirs, @constants_defined, @dependencies].each do |hash|
-          hash.keys.each do |k|
-            if k.start_with?(path_prefix)
-              hash[fix_path.call(k)] = hash.delete(k)
-            end
-          end
-        end
-
-        nil
-      end
-
       # Unload all reloadable constants and features, and clear the list
       # of files to monitor.
       def clear!
@@ -157,11 +110,7 @@ module Rack
         return if changed_files.empty?
 
         unless @dependencies.empty?
-          changed_files = reload_files(changed_files)
-          changed_files.flatten!
-          changed_files.map!{|f| File.directory?(f) ? Unreloader.ruby_files(f) : f}
-          changed_files.flatten!
-          changed_files.uniq!
+          changed_files = Unreloader.expand_directory_paths(reload_files(changed_files))
           
           order = @dependency_order
           order &= changed_files
@@ -169,14 +118,14 @@ module Rack
         end
 
         unless @skip_reload.empty?
-          skip_reload = @skip_reload.map{|f| File.directory?(f) ? Unreloader.ruby_files(f) : f}
-          skip_reload.flatten!
-          skip_reload.uniq!
-          changed_files -= skip_reload
+          changed_files -= Unreloader.expand_directory_paths(@skip_reload)
         end
 
+        changed_files.select! do |file|
+          @monitor_files.has_key?(file)
+        end
         changed_files.each do |file|
-          safe_load(file, FORCE)
+          safe_load(file)
         end
       end
 
@@ -200,14 +149,14 @@ module Rack
           begin
             safe_load(file, options)
           rescue NameError, LoadError => error
-            log "Cyclic dependency reload for #{error}"
+            log "Cyclic dependency reload for #{error.class}: #{error.message}"
           rescue Exception => error
+            log "Error: #{error.class}: #{error.message}"
             break
           end
         end
 
         if error
-          log error
           raise error
         end
       end
@@ -301,9 +250,6 @@ module Rack
       # by the require, and rolling back the constants and features if there
       # are any errors.
       def safe_load(file, options={})
-        return unless @monitor_files.has_key?(file)
-        return unless options[:force] || file_changed?(file)
-
         prepare(file) # might call #safe_load recursively
         log "Loading #{file}"
         begin

data/lib/rack/unreloader.rb

@@ -8,27 +8,31 @@ module Rack
     # Mutex used to synchronize reloads
     MUTEX = Monitor.new
 
-    # Reference to ::File as File would return Rack::File by default.
+    # Reference to ::File as File may return Rack::File by default.
     File = ::File
 
+    # Regexp for valid constant names, to prevent code execution.
+    VALID_CONSTANT_NAME_REGEXP = /\A(?:::)?([A-Z]\w*(?:::[A-Z]\w*)*)\z/.freeze
+
     # Given the list of paths, find all matching files, or matching ruby files
     # in subdirecories if given a directory, and return an array of expanded
     # paths.
     def self.expand_directory_paths(paths)
-      expand_paths(paths).
-        map{|f| File.directory?(f) ? ruby_files(f) : f}.
-        flatten
+      paths = expand_paths(paths)
+      paths.map!{|f| File.directory?(f) ? ruby_files(f) : f}
+      paths.flatten!
+      paths
     end
 
     # Given the path glob or array of path globs, find all matching files
     # or directories, and return an array of expanded paths.
     def self.expand_paths(paths)
-      Array(paths).
-        flatten.
-        map{|path| Dir.glob(path).sort_by{|filename| filename.count('/')}}.
-        flatten.
-        map{|path| File.expand_path(path)}.
-        uniq
+      paths = Array(paths).flatten
+      paths.map!{|path| Dir.glob(path).sort_by!{|filename| filename.count('/')}}
+      paths.flatten!
+      paths.map!{|path| File.expand_path(path)}
+      paths.uniq!
+      paths
     end
 
     # The .rb files in the given directory or any subdirectory.
@@ -40,11 +44,51 @@ module Rack
       files.sort
     end
 
+    # Autoload the file for the given objects.  objs should be a string, symbol,
+    # or array of them holding a Ruby constant name.  Access to the constant will
+    # load the related file.  A non-nil logger will have output logged to it.
+    def self.autoload_constants(objs, file, logger)
+      strings = Array(objs).map(&:to_s)
+      if strings.empty?
+        # Remove file from $LOADED_FEATURES if there are no constants to autoload.
+        # In general that is because the file is part of another class that will
+        # handle loading the file separately, and if that class is reloaded, we
+        # want to remove the loaded feature so the file can get loaded again.
+        $LOADED_FEATURES.delete(file)
+      else
+        logger.info("Setting up autoload for #{file}: #{strings.join(' ')}") if logger
+        strings.each do |s|
+          obj, mod = split_autoload(s)
+
+          if obj
+            obj.autoload(mod, file)
+          elsif logger
+            logger.info("Invalid constant name: #{s}")
+          end
+        end
+      end
+    end
+
+    # Split the given string into an array. The first is a module/class to add the
+    # autoload to, and the second is the name of the constant to be autoloaded.
+    def self.split_autoload(mod_string)
+      if m = VALID_CONSTANT_NAME_REGEXP.match(mod_string)
+        ns, sep, mod = m[1].rpartition('::')
+        if sep.empty?
+          [Object, mod]
+        else
+          [Object.module_eval("::#{ns}", __FILE__, __LINE__), mod]
+        end
+      end
+    end
+
     # The Rack::Unreloader::Reloader instead related to this instance, if one.
     attr_reader :reloader
 
     # Setup the reloader. Options:
     # 
+    # :autoload :: Whether to allow autoloading.  If not set to true, calls to
+    #              autoload will eagerly require the related files instead of autoloading.
     # :cooldown :: The number of seconds to wait between checks for changed files.
     #              Defaults to 1.  Set to nil/false to not check for changed files.
     # :handle_reload_errors :: Whether reload to handle reload errors by returning
@@ -58,12 +102,19 @@ module Rack
     #                match exactly, since modules don't have superclasses.
     def initialize(opts={}, &block)
       @app_block = block
+      @autoload = opts[:autoload]
+      @logger = opts[:logger]
       if opts.fetch(:reload, true)
         @cooldown = opts.fetch(:cooldown, 1)
         @handle_reload_errors = opts[:handle_reload_errors]
         @last = Time.at(0)
-        Kernel.require 'rack/unreloader/reloader'
-        @reloader = Reloader.new(opts)
+        if @autoload
+          require_relative('unreloader/autoload_reloader')
+          @reloader = AutoloadReloader.new(opts)
+        else
+          require_relative('unreloader/reloader')
+          @reloader = Reloader.new(opts)
+        end
         reload!
       else
         @reloader = @cooldown = @handle_reload_errors = false
@@ -86,6 +137,18 @@ module Rack
       @app_block.call.call(env)
     end
 
+    # Whether the unreloader is setup for reloading. If false, no reloading
+    # is done after the initial require.
+    def reload?
+      !!@reloader
+    end
+
+    # Whether the unreloader is setup for autoloading. If false, autoloads
+    # are treated as requires.
+    def autoload?
+      !!@autoload
+    end
+
     # Add a file glob or array of file globs to monitor for changes.
     # Options:
     # :delete_hook :: When a file being monitored is deleted, call
@@ -98,6 +161,24 @@ module Rack
       end
     end
 
+    # Add a file glob or array of file global to autoload and monitor
+    # for changes. A block is required.  It will be called with the
+    # path to be autoloaded, and should return the symbol for the
+    # constant name to autoload. Accepts the same options as #require.
+    def autoload(paths, opts={}, &block)
+      raise ArgumentError, "block required" unless block
+
+      if @autoload
+        if @reloader
+          @reloader.autoload_dependencies(paths, opts, &block)
+        else
+          Unreloader.expand_directory_paths(paths).each{|f| Unreloader.autoload_constants(yield(f), f, @logger)}
+        end
+      else
+        require(paths, opts, &block)
+      end
+    end
+
     # Records that each path in +files+ depends on +dependency+.  If there
     # is a modification to +dependency+, all related files will be reloaded
     # after +dependency+ is reloaded.  Both +dependency+ and each entry in +files+
@@ -128,17 +209,5 @@ module Rack
     def reload!
       @reloader.reload! if @reloader
     end
-
-    # Strip the given path prefix from all absolute paths used by the
-    # reloader.  This is designed when chrooting an application.
-    #
-    # Options:
-    # :strip_core :: Also strips the path prefix from $LOADED_FEATURES and
-    #              $LOAD_PATH.
-    def strip_path_prefix(path_prefix, opts={})
-      if @reloader
-        @reloader.strip_path_prefix(path_prefix)
-      end
-    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rack-unreloader
 version: !ruby/object:Gem::Version
-  version: 1.8.0
+  version: 2.1.0
 platform: ruby
 authors:
 - Jeremy Evans
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-10-15 00:00:00.000000000 Z
+date: 2023-01-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: minitest
@@ -66,12 +66,9 @@ files:
 - CHANGELOG
 - MIT-LICENSE
 - README.rdoc
-- Rakefile
 - lib/rack/unreloader.rb
+- lib/rack/unreloader/autoload_reloader.rb
 - lib/rack/unreloader/reloader.rb
-- spec/spec_helper.rb
-- spec/strip_paths_spec.rb
-- spec/unreloader_spec.rb
 homepage: http://github.com/jeremyevans/rack-unreloader
 licenses:
 - MIT
@@ -80,7 +77,7 @@ metadata:
   changelog_uri: https://github.com/jeremyevans/rack-unreloader/blob/master/CHANGELOG
   mailing_list_uri: https://github.com/jeremyevans/rack-unreloader/discussions
   source_code_uri: https://github.com/jeremyevans/rack-unreloader
-post_install_message: 
+post_install_message:
 rdoc_options:
 - "--quiet"
 - "--line-numbers"
@@ -95,15 +92,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.8.7
+      version: 1.9.2
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
-signing_key: 
+rubygems_version: 3.4.1
+signing_key:
 specification_version: 4
 summary: Reload application when files change, unloading constants first
 test_files: []

data/Rakefile

@@ -1,45 +0,0 @@
-require "rake"
-require "rake/clean"
-
-CLEAN.include ["rack-unreloader-*.gem", "rdoc"]
-
-desc "Build rack-unreloader gem"
-task :package=>[:clean] do |p|
-  sh %{#{FileUtils::RUBY} -S gem build rack-unreloader.gemspec}
-end
-
-### Specs
-
-desc "Run specs"
-task :spec do
-  sh "#{FileUtils::RUBY} #{'-w ' if RUBY_VERSION >= '3'}spec/unreloader_spec.rb"
-end
-
-task :default => :spec
-
-### RDoc
-
-RDOC_DEFAULT_OPTS = ["--quiet", "--line-numbers", "--inline-source", '--title', 'Rack::Unreloader: Reload application when files change, unloading constants first']
-
-begin
-  gem 'hanna-nouveau'
-  RDOC_DEFAULT_OPTS.concat(['-f', 'hanna'])
-rescue Gem::LoadError
-end
-
-rdoc_task_class = begin
-  require "rdoc/task"
-  RDoc::Task
-rescue LoadError
-  require "rake/rdoctask"
-  Rake::RDocTask
-end
-
-RDOC_OPTS = RDOC_DEFAULT_OPTS + ['--main', 'README.rdoc']
-
-rdoc_task_class.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
-  rdoc.options += RDOC_OPTS
-  rdoc.rdoc_files.add %w"README.rdoc CHANGELOG MIT-LICENSE lib/**/*.rb"
-end
-

data/spec/spec_helper.rb

@@ -1,87 +0,0 @@
-require File.join(File.dirname(File.expand_path(__FILE__)), '../lib/rack/unreloader')
-require 'rubygems'
-$: << 'lib'
-ENV['MT_NO_PLUGINS'] = '1' # Work around stupid autoloading of plugins
-gem 'minitest'
-require 'minitest/global_expectations/autorun'
-require 'minitest/hooks'
-
-module ModifiedAt
-  def set_modified_time(file, time)
-    time = Time.now + time if time.is_a?(Integer)
-    modified_times[File.expand_path(file)] = time
-  end
-
-  def modified_times
-    @modified_times ||= {}
-  end
-
-  private
-
-  def modified_at(file)
-    modified_times[file] || super
-  end
-end
-
-class Minitest::Spec
-  def code(i)
-    "class App; class << self; def call(env) @a end; alias call call; end; @a ||= []; @a << #{i}; end"
-  end
-
-  def update_app(code, file=@filename)
-    if ru.reloader
-      ru.reloader.set_modified_time(File.dirname(file), @i += 1) unless File.file?(file)
-      ru.reloader.set_modified_time(file, @i += 1)
-    end
-    File.open(file, 'wb'){|f| f.write(code)}
-  end
-
-  def file_delete(file)
-    if ru.reloader
-      ru.reloader.set_modified_time(File.dirname(file), @i += 1)
-    end
-    File.delete(file)
-  end
-
-  def logger
-    return @logger if @logger
-    @logger = []
-    def @logger.method_missing(meth, log)
-      self << log
-    end
-    @logger
-  end
-
-  def base_ru(opts={})
-    block = opts[:block] || proc{App}
-    @ru = Rack::Unreloader.new({:logger=>logger, :cooldown=>0}.merge(opts), &block)
-    @ru.reloader.extend ModifiedAt if @ru.reloader
-    Object.const_set(:RU, @ru)
-  end
-
-  def ru(opts={})
-    return @ru if @ru
-    base_ru(opts)
-    update_app(opts[:code]||code(1))
-    @ru.require @filename
-    @ru
-  end
-
-  def log_match(*logs)
-    @logger.length.must_equal logs.length
-    logs.zip(@logger).each{|l, log| l.is_a?(String) ? log.must_equal(l) : log.must_match(l)}
-  end
-
-  before do
-    @i = 0
-    @filename = 'spec/app.rb'
-  end
-
-  after do
-    ru.reloader.clear! if ru.reloader
-    Object.send(:remove_const, :RU)
-    Object.send(:remove_const, :App) if defined?(::App)
-    Object.send(:remove_const, :App2) if defined?(::App2)
-    Dir['spec/app*.rb'].each{|f| File.delete(f)}
-  end
-end