ioquatix-engines 2.1.0

data/CHANGELOG

@@ -0,0 +1,280 @@
+= EDGE
+
+* Samuel Williams (http://www.oriontransfer.co.nz/):
+	Updated asset helper to support a new syntax which is compatible with :cache. Retained old syntax behaviour too.
+	New syntax is as follows, for javascript and css helpers
+		javascript_include_tag [:plugin_name, 'jsfile'], [:other_plugin_name, 'jsfile']
+	This means all javascript files can be referenced in one helper, and thus :cache can be used to combine them all together.
+
+* Samuel Williams (http://www.oriontransfer.co.nz/):
+	Thanks to Tekin for his patches.
+	Updated migrations system to tie in more closely with the current rails mechanism.
+	Rake task for updating database schema info
+		rake db:migrate:upgrade_plugin_migrations
+	Please see http://engines.lighthouseapp.com/projects/10178-engines-plugin/tickets/17 for more information.
+
+* Refactored the view loading to work with changes in Edge Rails
+
+* Fixed integration of plugin migrations with the new, default timestamped migrations in Edge Rails
+
+* Refactored tests into the plugin itself - the plugin can now generate its own test_app harness and run tests within it.
+
+
+= 2.0.0 - (ANOTHER) MASSIVE INTERNAL REFACTORING
+
+* Engines now conforms to the new plugin loading mechanism, delegating plugin load order and lots of other things to Rails itself.
+
+
+
+= 1.2.2
+
+* Added the ability to code mix different types of files, cleaning up the existing code-mixing implementation slightly (Ticket #271)
+
+
+= 1.2.1
+
+* Added documentation to clarify some of the issues with Rails unloading classes that aren't required using "require_dependency" (Ticket #266)
+
+* Fixed a bug where test_help was being loaded when it wasn't needed, and was actually causing problems (Ticket #265)
+
+
+= 1.2.0 - MASSIVE INTERNAL REFACTORING
+
+* !!!Support for Rails < 1.2 has been dropped!!!; if you are using Rails =< 1.1.6, please use Engines 1.1.6, available from http://svn.rails-engines.org/engines/tags/rel_1.1.6
+
+* Engines are dead! Long live plugins! There is now no meaningful notion of an engine - all plugins can take advantage of the more powerful features that the engines plugin provides by including app directories, etc.
+
+* Init_engine.rb is no longer used; please use the plugin-standard init.rb instead.
+
+* Engines.start is no longer required; please use the config.plugins array provided by Rails instead
+
+* To get the most benefit from Engines, set config.plugins to ["engines", "*"] to load the engines plugin first, and then all other plugins in their normal order after.
+
+* Access all loaded plugins via the new Rails.plugins array, and by name using Rails.plugins[:plugin_name].
+
+* Access plugin metadata loaded automatically from about.yml: Rails.plugins[:name].about. Plugin#version is provided directly, for easy access.
+
+* Module.config is has been removed - use mattr_accessor instead, and initialize your default values via the init.rb mechanism.
+
+* Public asset helpers have been rewritten; instead of engine_stylesheet, now use stylesheet_link_tag :name, :plugin => "plugin_name"
+
+* Plugin migrations have been reworked to integrate into the main migration stream. Please run script/generate plugin_migration to create plugin migrations in your main application.
+
+* The fixture method for loading fixtures against any class has been removed; instead, engines will now provide a mechanism for loading fixtures from all plugins, by mirroring fixtures into a common location.
+
+* All references to engines have been removed; For example, any rake tasks which applied to engines now apply to all plugins. The default Rails rake tasks for plugins are overridden where necessary.
+
+* Layouts can now be shared via plugins - inspiration gratefully taken from PluginAWeek's plugin_routing :)
+
+* Actual routing from plugins is now possible, by including routes.rb in your plugin directory and using the from_plugin method in config/routes.rb (Ticket #182)
+
+* Controllers are no longer loaded twice if they're not present in the normal app/ directory (Ticket #177)
+
+* The preferred location for javascripts/stylesheets/etc is now 'assets' rather than 'public'
+
+* Ensure that plugins started before routing have their controllers appropriately added to config.controller_paths (Ticket #258)
+
+* Removed Engines.version - it's not longer relevant, now we're loading version information from about.yml files.
+
+* Added a huge amount of documentation to all new modules.
+
+* Added new warning message if installation of engines 1.2.x is attempted in a Rails 1.1.x application
+
+* Added details of the removal of the config method to UPGRADING
+
+* Removed the plugins:info rake task in favour of adding information to script/about via the Rails::Info module (Ticket #261)
+
+* Improved handling of testing and documentation tasks for plugins
+
+
+
+= 1.1.4
+
+* Fixed creation of multipart emails (Ticket #190)
+
+* Added a temporary fix to the code-mixing issue. In your engine's test/test_helper.rb, please add the following lines:
+
+   # Ensure that the code mixing and view loading from the application is disabled
+   Engines.disable_app_views_loading = true
+   Engines.disable_app_code_mixing = true
+
+  which will prevent code mixing for controllers and helpers, and loading views from the application. One thing to remember is to load any controllers/helpers using 'require_or_load' in your tests, to ensure that the engine behaviour is respected (Ticket #135)
+
+* Added tasks to easily test engines individually (Ticket #120)
+
+* Fixture extensions will now fail with an exception if the corresponding class cannot be loaded (Ticket #138)
+
+* Patch for new routing/controller loading in Rails 1.1.6. The routing code is now replaced with the contents of config.controller_paths, along with controller paths from any started engines (Ticket #196)
+
+* Rails' Configuration instance is now stored, and available from all engines and plugins.
+
+
+
+= 1.1.3
+
+* Fixed README to show 'models' rather than 'model' class (Ticket #167)
+* Fixed dependency loading to work with Rails 1.1.4 (Ticket #180)
+
+
+
+= 1.1.2
+
+* Added better fix to version checking (Ticket #130, jdell@gbdev.com).
+
+* Fixed generated init_engine.rb so that VERSION module doesn't cause probems (Ticket #131, japgolly@gmail.com)
+
+* Fixed error with Rails 1.0 when trying to ignore the engine_schema_info table (Ticket #132, snowblink@gmail.com)
+
+* Re-added old style rake tasks (Ticket #133)
+
+* No longer adding all subdirectories of <engine>/app or <engine>/lib, as this can cause issues when files are grouped in modules (Ticket #149, kasatani@gmail.com)
+
+* Fixed engine precidence ordering for Rails 1.1 (Ticket #146)
+
+* Added new Engines.each method to assist in processing the engines in the desired order (Ticket #146)
+
+* Fixed annoying error message at appears when starting the console in development mode (Ticket #134)
+
+* Engines is now super-careful about loading the correct version of Rails from vendor (Ticket #154)
+
+
+
+= 1.1.1
+
+* Fixed migration rake task failing when given a specific version (Ticket #115)
+
+* Added new rake task "test:engines" which will test engines (and other plugins) but ensure that the test database is cloned from development beforehand (Ticket #125)
+
+* Fixed issue where 'engine_schema_info' table was included in schema dumps (Ticket #87)
+
+* Fixed multi-part emails (Ticket #121)
+
+* Added an 'install.rb' file to new engines created by the bundled generator, which installs the engines plugin automatically if it doesn't already exist (Ticket #122)
+
+* Added a default VERSION module to generated engines (Ticket #123)
+
+* Refactored copying of engine's public files to a method of an Engine instance. You can now call Engines.get(:engine_name).copy_public_files (Ticket #108)
+
+* Changed engine generator templates from .rb files to .erb files (Ticket #106)
+
+* Fixed the test_helper.erb file to use the correct testing extensions and not load any schema - the schema will be cloned automatically via rake test:engines
+
+* Fixed problem when running with Rails 1.1.1 where version wasn't determined correctly (Ticket #129)
+
+* Fixed bug preventing engines from loading when both Rails 1.1.0 and 1.1.1 gems are installed and in use.
+
+* Updated version (d'oh!)
+
+
+
+= 1.1.0
+
+* Improved regexp matching for Rails 1.0 engines with peculiar paths
+
+* Engine instance objects can be accessed via Engines[:name], an alias for Engines.get(:name) (Ticket #99)
+
+* init_engine.rb is now processed as the final step in the Engine.start process, so it can access files within the lib directory, which is now in the $LOAD_PATH at that point. (Ticket #99)
+
+* Clarified MIT license (Ticket #98)
+
+* Updated Rake tasks to integrate smoothly with Rails 1.1 namespaces
+
+* Changed the version to "1.1.0 (svn)"
+
+* Added more information about using the plugin with Edge Rails to the README
+
+* moved extensions into lib/engines/ directory to enable use of Engines module in extension code.
+
+* Added conditional require_or_load method which attempts to detect the current Rails version. To use the Edge Rails version of the loading mechanism, add the line:
+
+*   Engines.config :edge, true
+
+* to your environment.rb file.
+
+* Merged changes from /branches/edge and /branches/rb_1.0 into /trunk
+
+* engine_schema_info now respects the prefix/suffixes set for ActiveRecord::Base (Ticket #67)
+
+* added ActiveRecord::Base.wrapped_table_name(name) method to assist in determining the correct table name
+
+
+
+= 1.0.6
+
+* Added ability to determine version information for engines: rake engine_info
+
+* Added a custom logger for the Engines module, to stop pollution of the Rails logs.
+
+* Added some more tests (in particular, see rails_engines/applications/engines_test).
+
+* Another attempt at solving Ticket #53 - controllers and helpers should now be loadable from modules, and if a full path (including RAILS_ROOT/ENGINES_ROOT) is given, it should be safely stripped from the require filename such that corresponding files can be located in any active engines. In other words, controller/helper overloading should now completely work, even if the controllers/helpers are in modules.
+
+* Added (finally) patch from Ticket #22 - ActionMailer helpers should now load
+
+* Removed support for Engines.start :engine, :engine_name => 'whatever'. It was pointless.
+
+* Fixed engine name referencing; engine_stylesheet/engine_javascript can now happily use shorthand engine names (i.e. :test == :test_engine) (Ticket #45)
+
+* Fixed minor documentation error ('Engine.start' ==> 'Engines.start') (Ticket #57)
+
+* Fixed double inclusion of RAILS_ROOT in engine_migrate rake task (Ticket #61)
+
+* Added ability to force config values even if given as a hash (Ticket #62)
+
+
+
+= 1.0.5
+
+* Fixed bug stopping fixtures from loading with PostgreSQL
+
+
+
+= 1.0.4
+
+* Another attempt at loading controllers within modules (Ticket #56)
+
+
+
+= 1.0.3
+
+* Fixed serious dependency bug stopping controllers being loaded (Ticket #56)
+
+
+
+= 1.0.2
+
+* Fixed bug with overloading controllers in modules from /app directory
+
+* Fixed exception thrown when public files couldn't be created; exception is now logged (Ticket #52)
+
+* Fixed problem with generated test_helper.rb file via File.expand_path (Ticket #50)
+
+
+
+= 1.0.1
+
+* Added engine generator for creation of new engines
+
+* Fixed 'Engine' typo in README
+
+* Fixed bug in fixtures extensions
+
+* Fixed /lib path management bug
+
+* Added method to determine public directory location from Engine object
+
+* Fixed bug in the error message in get_engine_dir()
+
+* Added proper component loading
+
+* Added preliminary tests for the config() methods module
+
+
+
+= pre-v170
+
+* Fixed copyright notices to point to DHH, rather than me.
+
+* Moved extension require statements into lib/engines.rb, so the will be loaded if another module/file calls require 'engines
+
+* Added a CHANGELOG file (this file)

data/MIT-LICENSE

@@ -0,0 +1,21 @@
+Copyright (c) 2008 James Adam
+
+The 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

@@ -0,0 +1,95 @@
+The gemified engines plugin is a work in progress. Thanks to all the people who have made engines possible. It is a great project.
+
+This is my fork of engines. I'll be maintaining it for as long as it is relevant.
+
+The engines plugin enhances Rails' own plugin framework, making it simple to share controllers, helpers, models, public assets, routes and migrations in plugins.
+
+For information regarding this particular gem, please see http://wiki.oriontransfer.org/?rails:engines
+
+For information regarding the original project, see http://rails-engines.org
+
+= Installing the gem
+
+	gem install ioquatix-engines --source=http://gems.github.com/
+
+= Using the plugin
+
+Once you've installed the engines plugin, you'll need to add a few lines to the top of config/environment.rb:
+
+	  # Bootstrap the Rails environment, frameworks, and default configuration
+	  require File.join(File.dirname(__FILE__), 'boot')
+
+	+ # Load engines plugin
+	+ gem 'ioquatix-engines', Rails::VERSION::STRING
+	+ require 'engines'
+  
+You should add this line just below the require for Rails' own boot.rb file.
+
+With that aside, you're now ready to start using more powerful plugins in your application. Read on to find out more about what the engines plugin enables.
+
+== Better plugins
+
+In addition to the regular set of plugin-supported files (lib, init.rb, tasks, generators, tests), plugins can carry the following when the engines plugin is also installed.
+
+=== Controllers, Helpers, and Views
+
+Include these files in an <tt>app</tt> directory just like you would in a normal Rails application. If you need to override a method, view or partial, create the corresponding file in your main <tt>app</tt> directory and it will be used instead.
+
+* Controllers & Helpers: See Engines::RailsExtensions::Dependencies for more information.
+* Views: now handled almost entirely by ActionView itself (see Engines::Plugin#add_plugin_view_paths for more information)
+
+=== Models
+
+Model code can similarly be placed in an <tt>app/models/</tt> directory. Unfortunately, it's not possible to automatically override methods within a model; if your application needs to change the way a model behaves, consider creating a subclass, or replacing the model entirely within your application's <tt>app/models/</tt> directory. See Engines::RailsExtensions::Dependencies for more information.
+
+IMPORTANT NOTE: when you load code from within plugins, it is typically not handled well by Rails in terms of unloading and reloading changes. Look here for more information - http://rails-engines.org/development/common-issues-when-overloading-code-from-plugins/
+
+=== Routes
+
+Include your route declarations in a <tt>routes.rb</tt> file at the root of your plugins, e.g.:
+
+  connect "/my/url", :controller => "some_controller"
+  my_named_route "do_stuff", :controller => "blah", :action => "stuff"
+  # etc.
+  
+You can then load these files into your application by declaring their inclusion in the application's <tt>config/routes.rb</tt>:
+
+  map.from_plugin :plugin_name
+
+See Engines::RailsExtensions::Routing for more information.
+  
+=== Migrations
+
+Migrations record the changes in your database as your application evolves. With engines 1.2, migrations from plugins can also join in this evolution as first-class entities. To add migrations to a plugin, include a <tt>db/migrate/</tt> folder and add migrations there as normal. These migrations can then be integrated into the main flow of database evolution by running the plugin_migration generator:
+
+  script/generate plugin_migration
+  
+This will produce a migration in your application. Running this migration (via <tt>rake db:migrate</tt>, as normal) will migrate the database according to the latest migrations in each plugin. See Engines::RailsExtensions::Migrations for more information.
+
+=== More powerful Rake tasks
+
+The engines plugin enhances and adds to the suite of default rake tasks for working with plugins. The <tt>doc:plugins</tt> task now includes controllers, helpers and models under <tt>app</tt>, and anything other code found under the plugin's <tt>code_paths</tt> attribute. New testing tasks have been added to run unit, functional and integration tests from plugins, whilst making it easier to load fixtures from plugins. See Engines::Testing for more details about testing, and run
+
+  rake -T
+  
+to see the set of rake tasks available.
+
+= Testing the engines plugin itself
+
+Because of the way the engines plugin modifies Rails, the simplest way to consistently test it against multiple versions is by generating a test harness application - a full Rails application that includes tests to verify the engines plugin behaviour in a real, running environment.
+
+Run the tests like this (example is on Mac OS X):
+
+  $ cd /Library/Ruby/Gems/1.8/gems/ioquatix-engines/
+  $ rake test
+  
+This will generate a test_app directory within the engines plugin (using the default 'rails' command), import tests and code into that application and then run the test suite.
+
+If you wish to test against a specific version of Rails, run the tests with the RAILS environment variable set to the local directory containing your Rails checkout
+
+  $ rake test RAILS=/Users/james/Code/rails_edge_checkout
+  
+Alternatively, you can clone the latest version of Rails ('edge rails') from github like so:
+
+  $ rake test RAILS=edge
+  

data/Rakefile

@@ -0,0 +1,199 @@
+require 'rake'
+require 'rake/rdoctask'
+require 'tmpdir'
+
+task :default => :doc
+
+desc 'Generate documentation for the engines plugin.'
+Rake::RDocTask.new(:doc) do |doc|
+  doc.rdoc_dir = 'doc'
+  doc.title    = 'Engines'
+  doc.main     = "README"
+  doc.rdoc_files.include("README", "CHANGELOG", "MIT-LICENSE")
+  doc.rdoc_files.include('lib/**/*.rb')
+  doc.options << '--line-numbers' << '--inline-source'
+end
+
+desc 'Run the engine plugin tests within their test harness'
+task :cruise do
+  # checkout the project into a temporary directory
+  version = "rails_2.0"
+  test_dir = "#{Dir.tmpdir}/engines_plugin_#{version}_test"
+  puts "Checking out test harness for #{version} into #{test_dir}"
+  `svn co http://svn.rails-engines.org/test/engines/#{version} #{test_dir}`
+
+  # run all the tests in this project
+  Dir.chdir(test_dir)
+  load 'Rakefile'
+  puts "Running all tests in test harness"
+  ['db:migrate', 'test', 'test:plugins'].each do |t|
+    Rake::Task[t].invoke
+  end  
+end
+
+task :clean => [:clobber_doc, "test:clean"]
+
+namespace :test do
+  
+  # Yields a block with STDOUT and STDERR silenced. If you *really* want
+  # to output something, the block is yielded with the original output
+  # streams, i.e.
+  #
+  #   silence do |o, e|
+  #     puts 'hello!' # no output produced
+  #     o.puts 'hello!' # output on STDOUT
+  #   end
+  #
+  # (based on silence_stream in ActiveSupport.)
+  def silence
+    yield(STDOUT, STDERR) if ENV['VERBOSE']
+    streams = [STDOUT, STDERR]
+    actual_stdout = STDOUT.dup
+    actual_stderr = STDERR.dup
+    streams.each do |s| 
+      s.reopen(RUBY_PLATFORM =~ /mswin/ ? 'NUL:' : '/dev/null') 
+      s.sync = true
+    end
+    yield actual_stdout, actual_stderr
+  ensure
+    STDOUT.reopen(actual_stdout)
+    STDERR.reopen(actual_stderr)
+  end
+  
+  def test_app_dir
+    File.join(File.dirname(__FILE__), 'test_app')
+  end
+  
+  def run(cmd)
+    cmd = cmd.join(" && ") if cmd.is_a?(Array)
+    system(cmd) || raise("failed running '#{cmd}'")
+  end
+  
+  desc 'Remove the test application'
+  task :clean do
+    FileUtils.rm_r(test_app_dir) if File.exist?(test_app_dir)
+  end
+  
+  desc 'Build the test rails application (use RAILS=[edge,<directory>] to test against specific version)'
+  task :generate_app do
+    silence do |out, err|
+      out.puts "> Creating test application at #{test_app_dir}"
+        
+      if ENV['RAILS']
+        vendor_dir = File.join(test_app_dir, 'vendor')
+        FileUtils.mkdir_p vendor_dir
+        
+        if ENV['RAILS'] == 'edge'
+          out.puts "    Cloning Edge Rails from GitHub"
+          run "cd #{vendor_dir} && git clone --depth 1 git://github.com/rails/rails.git"
+        elsif ENV['RAILS'] =~ /\d\.\d\.\d/
+          if ENV['CURL']
+            out.puts "    Cloning Rails Tag #{ENV['RAILS']} from GitHub using curl and tar"
+            run ["cd #{vendor_dir}",
+                 "mkdir rails",
+                 "cd rails",
+                 "curl -s -L http://github.com/rails/rails/tarball/#{ENV['RAILS']} | tar xzv --strip-components 1"]
+          else
+            out.puts "    Cloning Rails Tag #{ENV['RAILS']} from GitHub (can be slow - set CURL=true to use curl)"
+            run ["cd #{vendor_dir}",
+                 "git clone git://github.com/rails/rails.git",
+                 "cd rails",
+                 "git pull",
+                 "git checkout v#{ENV['RAILS']}"]
+          end
+        elsif File.exist?(ENV['RAILS'])
+          out.puts "    Linking rails from #{ENV['RAILS']}"
+          run "cd #{vendor_dir} && ln -s #{ENV['RAILS']} rails"
+        else
+          raise "Couldn't build test application from '#{ENV['RAILS']}'"
+        end
+      
+        out.puts "    generating rails default directory structure"
+        run "ruby #{File.join(vendor_dir, 'rails', 'railties', 'bin', 'rails')} #{test_app_dir}"
+      else
+        version = `rails --version`.chomp.split.last
+        out.puts "    building rails using the 'rails' command (rails version: #{version})"
+        run "rails #{test_app_dir}"
+      end
+    
+      # get the database config and schema in place
+      out.puts "    writing database.yml"
+      require 'yaml'
+      File.open(File.join(test_app_dir, 'config', 'database.yml'), 'w') do |f|
+        f.write(%w(development test).inject({}) do |h, env| 
+          h[env] = {"adapter" => "sqlite3", "database" => "engines_#{env}.sqlite3"} ; h
+        end.to_yaml)
+      end
+      out.puts "    installing exception_notification plugin"
+      run "cd #{test_app_dir} && ./script/plugin install exception_notification"
+    end
+  end
+  
+  def insert_line(line, options)
+    line = line + "\n"
+    target_file = File.join(test_app_dir, options[:into])
+    lines = File.readlines(target_file)
+    return if lines.include?(line)
+    
+    if options[:after]
+      if options[:after].is_a?(String)
+        after_line = options[:after] + "\n"
+      else
+        after_line = lines.find { |l| l =~ options[:after] }
+        raise "couldn't find a line matching #{options[:after].inspect} in #{target_file}" unless after_line
+      end
+      index = lines.index(after_line)
+      raise "couldn't find line '#{after_line}' in #{target_file}" unless index
+      lines.insert(index + 1, line)
+    else
+      lines << line
+    end
+    File.open(target_file, 'w') { |f| f.write lines.join }
+  end
+  
+  def mirror_test_files(src, dest=nil)
+    destination_dir = File.join(*([test_app_dir, dest].compact))
+    FileUtils.cp_r(File.join(File.dirname(__FILE__), 'test', src), destination_dir)
+  end
+  
+  desc 'Update the plugin and tests files in the test application from the plugin'
+  task :mirror_engine_files => [:test_app] do
+    puts "> Modifying default config files to load engines plugin"
+    insert_line("gem 'ioquatix-engines', Rails::VERSION::STRING\nrequire 'engines'",
+                :into => 'config/environment.rb',
+                :after => "require File.join(File.dirname(__FILE__), 'boot')")
+                
+    insert_line('map.from_plugin :test_routing', :into => 'config/routes.rb', 
+                :after => /\AActionController::Routing::Routes/)
+                
+    insert_line("require 'engines_test_helper'", :into => 'test/test_helper.rb')
+    
+    puts "> Mirroring test application files into #{test_app_dir}"
+    mirror_test_files('app')
+    mirror_test_files('lib')
+    mirror_test_files('plugins', 'vendor')
+    mirror_test_files('unit', 'test')
+    mirror_test_files('functional', 'test')
+  end
+  
+  desc 'Prepare the engines test environment'
+  task :test_app do
+    version_tag = File.join(test_app_dir, 'RAILS_VERSION')
+    existing_version = File.read(version_tag).chomp rescue 'unknown'
+    if existing_version == ENV['RAILS']
+      puts "> Reusing existing test application (#{ENV['RAILS']})"
+    else
+      puts "> Recreating test application"
+      Rake::Task["test:clean"].invoke
+      Rake::Task["test:generate_app"].invoke
+      
+      File.open(version_tag, "w") { |f| f.write ENV['RAILS'] }
+    end
+  end
+end
+
+task :test => "test:mirror_engine_files" do
+  puts "> Loading the test application environment and running tests"
+  # We use exec here to replace the current running rake process
+  exec("cd #{test_app_dir} && rake db:migrate && rake")
+end