reflection 0.4.6 → 0.5.0

data/History.rdoc

@@ -1,4 +1,15 @@
 === current HEAD
+
+* enhancements
+  * Move instead of copy to preserve even more cpu-io-wait
+  * Show the current version (--version)
+  * Rails: Recreate the database before applying a dump
+  * Rails: Run pending migrations after applying a dump
+
+=== 0.4.6 / 2009-11-19
+
+* fixes
+  * Fixed a blocking command call
     
 === 0.4.5 / 2009-11-19
 
@@ -6,5 +17,5 @@
   * Added --force option to skip moments of user-interaction
   * Replaced FileUtils#methods with its native brothers to gain more speed (and to preserve your cpu)
   
-* fixed
+* fixes
   * Fixed no-working repository-pull

data/README.rdoc

@@ -14,13 +14,9 @@ It provides two main command modes:
 
 Reflection is a gem, hosted on Gemcutter:
 
-
-  gem install gemcutter
-  gem tumble
   gem install reflection
 
 
-
 == Stashing your production data 
 
 ==== The simplest form:
@@ -102,9 +98,10 @@ If you have a <tt>reflection.yml</tt> config file in your current application-de
           --rails [RAILS_ROOT]         Enable dumping/applying of a Rails managed MySQL database
           --rails-env [ENV]            Rails environment to instrument
           --write [FILE]               Create a configuration FILE from the current commandline options
-      -v, --verbose                    Include debug information in output
           --force                      Hide tedious warnings
-      
+      -v, --verbose                    Include debug information in output
+          --version                    Show version
+
 
 == Note on Patches/Pull Requests
  

data/Reflection.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = %q{reflection}
-  s.version = "0.4.6"
+  s.version = "0.5.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Andreas Wolff"]
-  s.date = %q{2009-11-19}
+  s.date = %q{2009-12-01}
   s.default_executable = %q{reflection}
   s.description = %q{
       Reflection is designed to keep your development system in sync with your production system's files and database (by dumping).
@@ -20,7 +20,8 @@ Gem::Specification.new do |s|
   s.executables = ["reflection"]
   s.extra_rdoc_files = [
     "LICENSE",
-     "README.rdoc"
+     "README.rdoc",
+     "TODO"
   ]
   s.files = [
     ".document",
@@ -75,6 +76,7 @@ Gem::Specification.new do |s|
      "lib/reflection/directory/base.rb",
      "lib/reflection/directory/stash.rb",
      "lib/reflection/rails.rb",
+     "lib/reflection/rails/database.rb",
      "lib/reflection/repository.rb",
      "lib/reflection/support.rb",
      "lib/reflection/support/home.rb",
@@ -85,6 +87,7 @@ Gem::Specification.new do |s|
      "spec/reflection/config_spec.rb",
      "spec/reflection/directory/base_spec.rb",
      "spec/reflection/directory/stash_spec.rb",
+     "spec/reflection/rails/database_spec.rb",
      "spec/reflection/rails_spec.rb",
      "spec/reflection/repository_spec.rb",
      "spec/reflection/support/home_spec.rb",
@@ -104,6 +107,7 @@ Gem::Specification.new do |s|
      "spec/reflection/config_spec.rb",
      "spec/reflection/directory/base_spec.rb",
      "spec/reflection/directory/stash_spec.rb",
+     "spec/reflection/rails/database_spec.rb",
      "spec/reflection/rails_spec.rb",
      "spec/reflection/repository_spec.rb",
      "spec/reflection/support/home_spec.rb",

data/TODO

@@ -1,9 +1,10 @@
++ Allow for relative paths (enables one config for different machines)
 + Remove stash directory if its empty (on reinit)
 + Add Logger (Reflection::Support.log)
 + After command callbacks: Apphunk
++ Add cli option "use tmp-apply" --> (removes ~/.reflection/apply-dir after command) 
++ Allow collection of assets from Akamai and/or CloudFront (hm.. does that make sense?)
 + List existing reflections in client side
   + Allow to apply any (git) version, not just the latest
-+ Add cli option use tmp-apply (removes ~/.reflection/apply-dir after command) 
-+ Allow collection of assets from Akamai and/or CloudFront (hm.. does that make sense?)
-+ Add option to output --version
+
 - Remove ruby-git dependency

data/VERSION

@@ -1 +1 @@
-0.4.6
+0.5.0

data/lib/reflection.rb

@@ -23,5 +23,10 @@ module Reflection
       Reflection::CLI.run!(args)
     end
     
+    def version
+      File.open(File.expand_path(File.join(__FILE__, '../..', 'VERSION')), 'r') do |f|
+        f.readlines.first.to_s
+      end
+    end
   end
 end

data/lib/reflection/cli.rb

@@ -4,9 +4,14 @@ module Reflection
 
       def run!(args = nil)
         config = Reflection::Config.parse(args)
-
+        
+        if config.command == :show_version
+          puts "Version: #{Reflection.version}"
+          exit
+        end
+        
         if verify_config(config) == false
-          Reflection::Support.exit_with_error("Ahh ja, missing arguments. Please read 'reflection --help' to get a feeling of how it works.")
+          Reflection::Support.exit_with_error("Missing arguments. Please read 'reflection --help' to get a feeling of how it works.")
         else
           case config.command
             when :apply

data/lib/reflection/command/apply.rb

@@ -35,7 +35,7 @@ module Reflection
         else
           stash_directory.clone_repository
           stash_directory.move_content_to(target_directory.path)
-          stash_directory.get_git_index_from(target_directory.path)
+          # stash_directory.get_git_index_from(target_directory.path)
         end
 
         Reflection::Rails.apply(config, target_directory)

data/lib/reflection/command/stash.rb

@@ -35,18 +35,18 @@ module Reflection
       end
 
       def stash_directory_into_repository(stash_directory, target_directory)
-        copy_stash_repository_git_index_to_target(stash_directory.git_index, target_directory.path)
+        move_stash_repository_git_index_to_target(stash_directory.git_index, target_directory.path)
         Reflection::Rails.stash(config, target_directory) if config.rails_root
         commit_and_push_files(target_directory.path, target_directory.name)
         move_stash_repository_git_index_back(target_directory.git_index, stash_directory.path)
-        Reflection::Rails.clean_target(target_directory) if config.rails_root
+        Reflection::Rails.clean_target(config, target_directory) if config.rails_root
       end
 
 
       private
 
-        def copy_stash_repository_git_index_to_target(source, target)
-          %x(cp -R #{source} #{target})
+        def move_stash_repository_git_index_to_target(source, target)
+          %x(mv #{source} #{target})
         end
 
         def commit_and_push_files(repository_path, target)
@@ -56,7 +56,6 @@ module Reflection
         end
 
         def move_stash_repository_git_index_back(source, target)
-          %x(rm -rf #{File.join(target, "/.git")})
           %x(mv #{source} #{target})
         end
 

data/lib/reflection/config.rb

@@ -118,13 +118,17 @@ module Reflection
           self.store_configuration_path = config_file_path if config_file_path
         end
 
+        opts.on("--force", "Hide tedious warnings") do
+          self.force = true
+        end
+
         opts.on("-v", "--verbose", "Include debug information in output") do
           self.verbose = true
           Reflection.verbose = true
         end
 
-        opts.on("--force", "Hide tedious warnings") do
-          self.force = true
+        opts.on("--version", "Show version") do
+          self.command = :show_version
         end
       end
 

data/lib/reflection/directory/base.rb

@@ -48,8 +48,9 @@ module Reflection
       
       def move_content_to(target_path)
         Reflection.log.debug "Moving content to '#{target_path}'.."
-        %x(cp -R #{File.join(self.path, '/.')} #{target_path})
-        %x(rm -rf #{self.path})
+        %x(mv #{File.join(self.path, '/*')} #{File.join(target_path, '/')})
+        # %x(cp -R #{File.join(self.path, '/.')} #{target_path})
+        # %x(rm -rf #{self.path})
       end
       
     end

data/lib/reflection/rails.rb

@@ -1,5 +1,8 @@
 module Reflection
   module Rails
+    
+    autoload :Database, 'reflection/rails/database'
+    
     class << self
       
       def validate_environment(config)
@@ -9,52 +12,27 @@ module Reflection
         end
       end
       
-      def clean_target(target_directory)
-        target_file_path = File.join(target_directory.path, '_rails_database_dump.sql')
-        if File.exist?(target_file_path)
-          %x(rm #{target_file_path})          
-        end
-      end
-      
-      def database_command_line_options(database_config)
-        options = []
-        options <<  "-h #{database_config['host']}"
-        options <<  "-u#{database_config['username']}"
-        options <<  "-p#{database_config['password']}" if database_config['password'] && !database_config['password'].empty?
-        options <<  "#{database_config['database']}"
-        options.join(' ')
-      end
-      
-      def read_database_configuration(config)
-        begin
-          database_path = File.join(config.rails_root, "config/database.yml")
-          if db_config = YAML.load_file(database_path)[config.rails_environment]
-            return db_config
-          else
-            Reflection.log.error("Rails database configuration for '#{config.rails_environment}' isn't available in #{database_path}")
-            return false
-          end
-        rescue => e
-          Reflection.log.error("Error while parsing Rails database configuration: #{e}")
-          return false
-        end
+      # TODO: 
+      # Method is obsolete and has moved to Rails::Database
+      # Cannot be removed atm because Command::Stash depends on it
+      def clean_target(config, target_directory)
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.clean_dump_file(target_directory.path)
       end
       
       def stash(config, target_directory)
         Reflection.log.debug "Stashing database dump.."
-        return unless database_config = read_database_configuration(config)
-        options = database_command_line_options(database_config)
-        target_file_path = File.join(target_directory.path, '_rails_database_dump.sql')
-        %x(mysqldump #{options} --add-drop-table > #{target_file_path})
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.dump_to_directory(target_directory.path)
       end
     
       def apply(config, target_directory)
         Reflection.log.debug "Applying database dump.."        
-        return unless database_config = read_database_configuration(config)
-        options = database_command_line_options(database_config)
-        target_file_path = File.join(target_directory.path, '_rails_database_dump.sql')
-        %x(mysql #{options} < #{target_file_path})
-        clean_target(target_directory)
+        database = Database.new(config.rails_root, config.rails_environment)
+        database.recreate!
+        database.load_dump_from_file(target_directory.path)
+        database.clean_dump_file(target_directory.path)
+        database.migrate!
       end
       
     end

data/lib/reflection/rails/database.rb

@@ -0,0 +1,95 @@
+module Reflection
+  module Rails
+    class Database
+
+      attr_accessor :configuration
+      attr_accessor :environment
+      attr_accessor :rails_root
+
+      def initialize(new_rails_root, new_environment)
+        self.rails_root = new_rails_root
+        self.environment = new_environment
+        self.configuration = read_configuration_yml
+      end
+
+      def dump_to_directory(target_directory)
+        run("mysqldump #{command_line_options} > #{dump_file_path(target_directory)}")
+      end
+
+      def load_dump_from_file(target_directory)
+        Reflection.log.debug "Loading dump.."
+        run("mysql #{command_line_options(:no_rehash => true)} < #{dump_file_path(target_directory)}")
+      end
+
+      def clean_dump_file(target_directory)
+        dump_file = dump_file_path(target_directory)
+        if File.exist?(dump_file)
+          run "rm #{dump_file}"
+        end
+      end
+
+      def recreate!
+        Reflection.log.debug "Recreating database.."
+        drop
+        create
+      end
+      
+      def create
+        run("echo \"CREATE DATABASE #{self.configuration['database']};\" | mysql #{command_line_options(:skip => :database)}")
+      end
+      
+      def drop
+        run("echo \"DROP DATABASE #{self.configuration['database']};\" | mysql #{command_line_options(:skip => :database)}")
+      end
+      
+      def migrate!
+        Reflection.log.debug "Migrating database.."
+        run("(cd #{self.rails_root} && RAILS_ENV=#{self.environment} rake db:migrate)")
+      end
+
+      def read_configuration_yml
+        begin
+          if configuration = YAML.load_file(database_config_file_path)[self.environment]
+            return configuration
+          else
+            return Support.exit_with_error("Rails database configuration for '#{self.environment}' isn't available in #{database_config_file_path}")
+          end
+        rescue => e
+          return Support.exit_with_error("Error while parsing Rails database configuration: #{e}")
+        end
+      end
+
+      def command_line_options(opts = {})
+        options = []
+        options <<  "-A" if opts[:no_rehash] && opts[:no_rehash] == true
+        options <<  "-h #{configuration['host']}"
+        options <<  "-u#{configuration['username']}"
+        options <<  "-p#{configuration['password']}" if configuration['password'] && !configuration['password'].empty?
+        options <<  "#{configuration['database']}" unless opts[:skip] && opts[:skip] == :database
+        options.join(' ')
+      end
+
+      def run(command)
+        # Reflection.log.debug "-- #{command}"
+        %x(#{command})
+      end
+      
+
+      private
+
+        def log_error_and_return_false(message)
+          Reflection.log.error(message)
+          return false
+        end
+
+        def database_config_file_path
+          @database_config_file_path ||= File.join(self.rails_root, "config/database.yml")
+        end
+        
+        def dump_file_path(directory)
+          File.join(directory, "_rails_database_dump.sql")
+        end
+        
+    end
+  end
+end

data/spec/reflection/command/stash_spec.rb

@@ -73,18 +73,19 @@ describe Reflection::Command::Stash do
       @mock_stash_repository.stub!(:repository).and_return(@mock_stash_repository)
       @mock_target_directory = mock('Directory::Base', :name => 'assets', :path => '/home/tmp/assets', :git_index => '/home/tmp/assets/.git')
 
-      @subject.stub!(:copy_stash_repository_git_index_to_target)
+      @subject.stub!(:move_stash_repository_git_index_to_target)
       @subject.stub!(:commit_and_push_files)
       @subject.stub!(:move_stash_repository_git_index_back)
     end
     
     it "should move the stash-repository-directory (.git) one level above the asset directory path" do
-      @subject.should_receive(:copy_stash_repository_git_index_to_target).with("/home/stash/path/.git", "/home/tmp/assets")
+      @subject.should_receive(:move_stash_repository_git_index_to_target).with("/home/stash/path/.git", "/home/tmp/assets")
       @subject.stash_directory_into_repository(@mock_stash_directory, @mock_target_directory)
     end
     
     it 'should call the stash command on the database dumper if enabled' do
       @config.rails_root = "/rails/root"
+      Reflection::Rails.stub!(:clean_target)
       Reflection::Rails.should_receive(:stash).with(@config, @mock_target_directory)
       @subject.stash_directory_into_repository(@mock_stash_directory, @mock_target_directory)
     end

data/spec/reflection/rails/database_spec.rb

@@ -0,0 +1,161 @@
+require File.dirname(__FILE__) + '/../../spec_helper'
+
+describe Reflection::Rails::Database do
+  before(:each) do
+    YAML.stub!(:load_file).and_return({ 'development' => {} })
+    @database = Reflection::Rails::Database.new('/rails_root', 'development')
+  end
+  
+  describe '#initialize' do
+    it 'should read the configuration file during init' do
+      YAML.should_receive(:load_file)
+      Reflection::Rails::Database.new('/rails_root', 'development')
+    end
+    
+    it 'should exit with error if initialization failed' do
+      Reflection::Support.should_receive(:exit_with_error)
+      YAML.stub!(:load_file).and_raise(StandardError)
+      Reflection::Rails::Database.new('/rails_root', 'development')
+    end
+  end
+  
+  describe '#create' do
+    before(:each) do
+      @database.configuration = { "database" => "test" }
+      @database.stub!(:command_line_options).and_return('options')
+    end
+    
+    it 'should create the database' do
+      @database.should_receive(:run).with(/^echo "CREATE DATABASE test;"/)
+      @database.create
+    end
+  end
+
+  describe '#drop' do
+    before(:each) do
+      @database.configuration = { "database" => "test" }
+      @database.stub!(:command_line_options).and_return('options')
+    end
+    
+    it 'should drop the database' do
+      @database.should_receive(:run).with(/^echo "DROP DATABASE test;"/)
+      @database.drop
+    end
+  end
+  
+  describe '#recreate!' do
+    before(:each) do
+      @database.stub!(:create)
+      @database.stub!(:drop)
+    end
+    
+    it 'should drop the database' do
+      @database.should_receive(:drop)
+      @database.recreate!
+    end
+  
+    it 'should create the database' do
+      @database.should_receive(:create)
+      @database.recreate!
+    end
+  end
+  
+  describe '#migrate!' do
+    before(:each) do
+    end
+    
+    it 'should run the migrate command' do
+      @database.should_receive(:run).with(/rake db:migrate/)
+      @database.migrate!
+    end
+    
+    it 'should temporarily cd into the rails root' do
+      @database.should_receive(:run).with(/cd \/rails_root/)
+      @database.migrate!
+    end
+    
+    it 'should instrument the specified environment' do
+      @database.should_receive(:run).with(/RAILS_ENV=development/)
+      @database.migrate!
+    end
+  end
+  
+  describe '#dump_to_directory' do
+    before(:each) do
+      @database.stub!(:command_line_options).and_return('options')
+    end
+    
+    it 'should dump the database into the target directory' do
+      @database.should_receive(:run).with(/mysqldump options/)
+      @database.dump_to_directory('path')
+    end
+    
+    it 'should dump the database into a special dump file' do
+      @database.should_receive(:run).with(/> path\/_rails_database_dump.sql$/)
+      @database.dump_to_directory('path')
+    end    
+  end
+  
+  describe '#load_dump_from_file' do
+    before(:each) do
+      @database.stub!(:command_line_options).and_return('options')
+    end
+    
+    it 'should load the dump into the database' do
+      @database.should_receive(:run).with(/mysql options/)
+      @database.load_dump_from_file('path')
+    end
+    
+    it 'should dump the database into a special dump file' do
+      @database.should_receive(:run).with(/< path\/_rails_database_dump.sql$/)
+      @database.load_dump_from_file('path')
+    end    
+  end
+  
+  describe '#read_configuration_yml' do
+    before(:each) do
+      @db_config = { "host" => "localhost", "username" => "root" }
+    end
+    
+    it 'should read the configuration for the specified environment' do
+      YAML.should_receive(:load_file).with('/rails_root/config/database.yml').and_return({ "production" => {}, "development" => @db_config })
+      @database.read_configuration_yml.should == @db_config
+    end
+    
+    it 'should not load the configuration twice' do
+      YAML.should_receive(:load_file).once.and_return({ "production" => {}, "development" => @db_config })
+      @database.read_configuration_yml
+      @database.read_configuration_yml
+    end
+    
+    it "should #exit_with_error if the environment isn't configured" do
+      Reflection::Support.should_receive(:exit_with_error).with(/available/)
+      YAML.stub!(:load_file).and_return({ "production" => {} })
+      @database.read_configuration_yml
+    end
+    
+    it "should #exit_with_error if the database.yml cannot be found" do
+      Reflection::Support.should_receive(:exit_with_error).with(/Error/)
+      YAML.stub!(:load_file).and_raise(StandardError)
+      @database.read_configuration_yml
+    end
+  end
+  
+  describe '#command_line_options' do
+    before(:each) do
+      @database.configuration = { "host" => "localhost", "database" => "test", "username" => "root", "password" => "secret" }
+    end
+    
+    it 'should create options for the mysql command' do
+      @database.command_line_options.should == "-h localhost -uroot -psecret test"
+    end
+    
+    it 'should ignore the password option if its not available' do
+      @database.configuration['password'] = ""
+      @database.command_line_options.should == "-h localhost -uroot test"
+    
+      @database.configuration['password'] = nil
+      @database.command_line_options.should == "-h localhost -uroot test"
+    end
+  end
+end

data/spec/reflection/rails_spec.rb

@@ -14,42 +14,49 @@ describe Reflection::Rails do
     end
   end
   
-  describe 'read_database_configuration' do
-    it 'should read the configuration for the specified environment' do
-      db_config = { "host" => "localhost", "username" => "root" }
-      YAML.should_receive(:load_file).with('/rails_root/config/database.yml').and_return({ "production" => {}, "development" => db_config })
-      db_config = @rails.read_database_configuration(@config)
-      db_config.should == db_config
-    end
-    
-    it "should log an error and return false if the environment isn't configured" do
-      Reflection.log.should_receive(:error).with(/available/)
-      YAML.stub!(:load_file).and_return({ "production" => {} })
-      @rails.read_database_configuration(@config).should be_false
+  describe 'stash' do
+    before(:each) do
+      @mock_target = mock('Reflection::Directory', :path => 'target')
+      @mock_database = mock('Reflection::Rails::Database')
+      Reflection::Rails::Database.stub!(:new).and_return(@mock_database)
     end
     
-    it "should log an error and return false if the database.yml cannot be found" do
-      Reflection.log.should_receive(:error).with(/Error/)
-      YAML.stub!(:load_file).and_raise(StandardError)
-      @rails.read_database_configuration(@config).should be_false
+    it 'should should dump the database to the target directory' do
+      @mock_database.should_receive(:dump_to_directory).with('target')
+      @rails.stash(@config, @mock_target)
     end
   end
   
-  describe 'database_command_line_options' do
+  describe 'apply' do
     before(:each) do
-      @db_config = { "host" => "localhost", "database" => "test", "username" => "root", "password" => "secret" }
+      @mock_target = mock('Reflection::Directory', :path => 'target')
+      @mock_database = mock('Reflection::Rails::Database')
+      @mock_database.stub!(:recreate!)
+      @mock_database.stub!(:load_dump_from_file)
+      @mock_database.stub!(:clean_dump_file)
+      @mock_database.stub!(:migrate!)
+      Reflection::Rails::Database.stub!(:new).and_return(@mock_database)
     end
     
-    it 'should create options for the mysql command' do
-      @rails.database_command_line_options(@db_config).should == "-h localhost -uroot -psecret test"
+    it 'should recreate the database before apply a dump' do
+      @mock_database.should_receive(:recreate!)
+      @rails.apply(@config, @mock_target)
     end
     
-    it 'should ignore the password option if its not available' do
-      @db_config['password'] = ""
-      @rails.database_command_line_options(@db_config).should == "-h localhost -uroot test"
+    it 'should should load the dump from the target directory into the database' do
+      @mock_database.should_receive(:load_dump_from_file).with('target')
+      @rails.apply(@config, @mock_target)
+    end
 
-      @db_config['password'] = nil
-      @rails.database_command_line_options(@db_config).should == "-h localhost -uroot test"
+    it 'should should remove the dump file from target' do
+      @mock_database.should_receive(:clean_dump_file).with('target')
+      @rails.apply(@config, @mock_target)
+    end
+
+    it 'should should migrate the database after applying a dump' do
+      @mock_database.should_receive(:migrate!)
+      @rails.apply(@config, @mock_target)
     end
   end
+  
 end

data/spec/spec_helper.rb

@@ -9,6 +9,7 @@ Spec::Runner.configure do |config|
     @global_mock_log = mock('Log')
     @global_mock_log.stub!(:debug)
     @global_mock_log.stub!(:info)
+    @global_mock_log.stub!(:error)
     Reflection.stub!(:log).and_return(@global_mock_log)
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification 
 name: reflection
 version: !ruby/object:Gem::Version 
-  version: 0.4.6
+  version: 0.5.0
 platform: ruby
 authors: 
 - Andreas Wolff
@@ -9,7 +9,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2009-11-19 00:00:00 +01:00
+date: 2009-12-01 00:00:00 +01:00
 default_executable: reflection
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -41,6 +41,7 @@ extensions: []
 extra_rdoc_files: 
 - LICENSE
 - README.rdoc
+- TODO
 files: 
 - .document
 - .gitignore
@@ -94,6 +95,7 @@ files:
 - lib/reflection/directory/base.rb
 - lib/reflection/directory/stash.rb
 - lib/reflection/rails.rb
+- lib/reflection/rails/database.rb
 - lib/reflection/repository.rb
 - lib/reflection/support.rb
 - lib/reflection/support/home.rb
@@ -104,6 +106,7 @@ files:
 - spec/reflection/config_spec.rb
 - spec/reflection/directory/base_spec.rb
 - spec/reflection/directory/stash_spec.rb
+- spec/reflection/rails/database_spec.rb
 - spec/reflection/rails_spec.rb
 - spec/reflection/repository_spec.rb
 - spec/reflection/support/home_spec.rb
@@ -145,6 +148,7 @@ test_files:
 - spec/reflection/config_spec.rb
 - spec/reflection/directory/base_spec.rb
 - spec/reflection/directory/stash_spec.rb
+- spec/reflection/rails/database_spec.rb
 - spec/reflection/rails_spec.rb
 - spec/reflection/repository_spec.rb
 - spec/reflection/support/home_spec.rb