exodus 1.0.0 → 1.0.1

data/.rspec

@@ -0,0 +1,4 @@
+--color
+--format documentation
+--default_path spec/
+--pattern **/*.rb

data/.rvmrc

@@ -0,0 +1 @@
+rvm use ruby-1.9.3-p194@exodus

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - rbx-19mode
+branches:
+  only:
+    - master
+notifications:
+  email:
+    recipients:
+      - thomas.dmytryk@supinfo.com
+script: bundle exec rspec spec

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+## v1.0.1
+
+* Small refactoring
+
+## v1.0.0
+
+* Initial release

data/README.md

@@ -3,15 +3,15 @@ Exodus - a migration framework for MongoDb
 
 # Intro 
 
-## A migration Framework for a schemaless database ???
+## A migration Framework for a schemaless database ??
 
-  After working with Mongo for long time now I can tell you it doesn't mean you will never need any migrations. Within the same collection Mongo allows to have documents with a complete different structure, however in some case is you might want to keep data consistency in your collections; Especially when your code is live in production and used by millions of users. 
+  After working with Mongo for long time now I can tell you working with a schemaless database does not mean you will never need any migrations. Within the same collection Mongo allows to have documents with a complete different structure, however in some case is you might want to keep data consistency; Especially when your code is live in production and used by millions of users. 
 
   There is a plenty of way to modify documents data structure and after a deep reflexion I realized it makes more sens to use migration framework. A migration framework provides a lot of advantages, such as: 
 
   * It allows you to know at any time which migration has been ran on any given system  
   * It's Auto runnable on deploy
-	* When switching enviromment (dev, pre-prod, prod) you don't need to worry if the script has been ran or not. The framework takes care of it for you
+  * When switching enviromment (dev, pre-prod, prod) you don't need to worry if the script has been ran or not. The framework takes care of it for you
 
 
 # Installation

data/exodus.gemspec

@@ -4,7 +4,7 @@ require File.expand_path('../lib/exodus/version', __FILE__)
 Gem::Specification.new do |gem|
   gem.authors       = ['Thomas Dmytryk']
   gem.email         = ['thomas@fanhattan.com', 'thomas.dmytryk@supinfo.com']
-  gem.description   = %q{Exodus is a migration framework for Mongo}
+  gem.description   = %q{Exodus is a migration framework for MongoDb}
   gem.summary       = %q{Exodus uses mongomapper to provide a complete migration framework}
   gem.homepage      = ''
   gem.license       = 'MIT'

data/lib/exodus.rb

@@ -1,5 +1,8 @@
 require 'mongo_mapper'
-Dir[File.dirname(__FILE__) + "/exodus/**/*.rb"].sort.each { |file| require file}
+require File.dirname(__FILE__) + '/exodus/config/migration_info'
+require File.dirname(__FILE__) + '/exodus/migrations/migration'
+require File.dirname(__FILE__) + '/exodus/migrations/migration_error'
+require File.dirname(__FILE__) + '/exodus/migrations/migration_status'
 
 module Exodus
 	class << self
@@ -13,39 +16,43 @@ module Exodus
 		  yield(configuration) if block_given?
 		end
 
-		# Loads and runs a number of migrations equal to step (or all of them if step is nil)
+		# Executes a number of migrations equal to step (or all of them if step is nil)
 		def run_migrations(direction, migrations, step = nil)			
 			if migrations
-				sorted_migrations = sort_migrations(migrations)
 				sorted_migrations = order_with_direction(sorted_migrations, direction)
 				sorted_migrations = sorted_migrations.shift(step.to_i) if step 
 
-				sorted_migrations.each {|migration_class, args| run_each(migration_class, direction, args)} 
+				run_each(sorted_migrations)
 			else
 				puts "no migrations given in argument!"
 			end
 		end
 
-	  def sort_migrations(migrations)
-	    migrations.sort_by {|migration,args| migration.migration_number }
+	  # Migrations order need to be reverted if the direction is down 
+	  # (we want the latest executed migration to be the first reverted)
+	  def order_with_direction(migrations, direction)
+	  	sorted_migrations = sort_migrations(migrations)
+	  	direction == Migration::UP ? sorted_migrations : sorted_migrations.reverse 
 	  end
 
-	  def order_with_direction(migrations, direction)
-	  	direction == Migration::UP ? migrations : migrations.reverse 
+	  def sort_migrations(migrations)
+	    migrations.sort_by {|migration,args| migration.migration_number }
 	  end
 
-	  def run_each(migration_class, direction, args = {})
-	  	puts "\n"
-	  	args ||= {}
-	  	
-	  	run_one_migration(migration_class, direction, args)
-	  	puts "\n"
+	  # Runs each migration separately, migration's arguments default value is set to an empty hash
+	  def run_each(direction, migrations)
+	  	migrations.each do |migration_class, args|
+		  	print_tabulation { run_one_migration(migration_class, direction, args || {}) }
+		  end
 	  end
 
+	  # Looks up in the database if a migration with the same class and same arguments already exists
+	  # Otherwise instanciate a new one
+	  # Runs the migration if it is runnable
 	  def run_one_migration(migration_class, direction, args)
 	  	# Going throught MRD because MM request returns nil for some reason
 	  	current_migration = migration_class.load(migration_class.collection.find('status.arguments' => args).first)
-	  	current_migration ||= migration_class.new(status: {arguments: args})
+	  	current_migration ||= migration_class.new(:status => {:arguments => args})
 
 	  	if current_migration.is_runnable?(direction)
 	  		# Make sure we save all info in case of a failure 
@@ -58,11 +65,19 @@ module Exodus
 	  			raise
 	  		end
 
-	  		# save the migration
 	    	current_migration.save!
 	    else
 	    	puts "#{current_migration.class}#{current_migration.status.arguments}(#{direction}) as Already been run (or is not runnable)."
 	    end
 	  end
+
+	  private
+
+	  # Prints tabulation before execting a given block
+	  def print_tabulation
+	  	puts "\n"
+		  yield if block_given?
+		  puts "\n"
+	  end
 	end
 end

data/lib/exodus/config/migration_info.rb

@@ -0,0 +1,59 @@
+module Exodus
+	class MigrationInfo
+		attr_accessor :info
+		attr_reader :config_file, :db, :connection
+
+		def initialize(file = nil)
+			config_file = file if file 
+		end
+
+		def db=(database)
+			MongoMapper.database = database
+		end
+
+		def connection=(conn)
+			MongoMapper.connection = conn
+		end
+
+		def config_file=(file)
+			if File.exists?(file)
+				@config_file = file
+				@info = YAML.load_file(file)
+			else
+				raise ArgumentError, "#{file} not found"
+			end
+		end
+
+		def migrate
+			verify_yml_syntax { @info['migration']['migrate'] }
+		end
+
+		def rollback
+			verify_yml_syntax { @info['migration']['rollback'] }
+		end
+
+		def migrate_custom
+			verify_yml_syntax { @info['migration']['custom']['migrate'] }
+		end
+
+		def rollback_custom
+			verify_yml_syntax { @info['migration']['custom']['rollback'] }
+		end
+
+		def to_s
+			@info
+		end
+
+		private 
+
+		def verify_yml_syntax
+			Raise StandardError, "No configuration file specified" unless self.config_file
+
+			begin
+				yield if block_given?
+			rescue
+				Raise StandardError, "Syntax error detected in config file #{self.config_file}. To find the good syntax take a look at the documentation."
+			end
+		end
+	end
+end

data/lib/exodus/migrations/migration.rb

@@ -0,0 +1,165 @@
+module Exodus
+  class Migration
+    include MongoMapper::Document
+    UP = 'up'
+    DOWN = 'down'
+    @migrations_with_args = []
+
+    timestamps!
+
+    key :description,                 String
+    key :status_complete,             Integer, :default => 1
+    key :rerunnable_safe,             Boolean, :default => false  # Be careful if the job is rerunnable_safe he will re-run on each db:migrate
+
+    has_one :status, :class_name => "Exodus::MigrationStatus", :autosave => true
+
+    class << self 
+      attr_accessor :migration_number
+
+      # Overides #inherited to have an easy and reliable way to find all migrations
+      # Migrations need to have embedded callbacks on depending on the MM's version 
+      def inherited(klass)
+        klass.embedded_callbacks_on if defined?(MongoMapper::Plugins::EmbeddedCallbacks::ClassMethods) #MongoMapper version compatibility
+        klass.migration_number = 0
+        @migrations_with_args << [klass]
+        super(klass)
+      end
+
+      # Using a list of migrations
+      # Formats and overrides migrations without arguments using ones that have given arguments
+      # Removes duplicates 
+      # migrations: list of migrations => [[MyMigration, {:my_args => 'some_args'}]] 
+      def load_all(migrations)
+        if migrations
+          migrations.each do |migration, args|
+            if migration && args
+              formated_migration = format(migration, args)
+              migration, args = formated_migration
+
+              unless @migrations_with_args.include?(formated_migration)
+                @migrations_with_args.delete_if {|loaded_migration, loaded_args| migration == loaded_migration && (loaded_args.nil? || loaded_args.empty?) }
+                @migrations_with_args << formated_migration
+              end
+            end
+          end 
+        end
+
+        @migrations_with_args
+      end
+
+      # Using a list of migrations formats them and removes duplicates 
+      # migrations: list of migrations => [[MyMigration, {:my_args => 'some_args'}]] 
+      def load_custom(migrations)
+        migrations.map {|migration_str, args| format(migration_str, args) }.uniq
+      end
+
+      # Formats a given migration making sure the first argument is a class
+      # and the second one -if it exists- is a none empty hash
+      def format(migration, args = {})
+        migration_klass = migration.is_a?(String) ? migration.constantize : migration
+        args.is_a?(Hash) && args.empty? ? [migration_klass] : [migration_klass, args]
+      end
+
+      # Prints in the console all migrations class with their name and description  
+      def list
+        puts "\n Migration n#:  \t\t   Name: \t\t\t\t Description:"
+        puts '-' * 100, "\n"
+
+        @migrations_with_args.map do|migration, args|
+          m = migration.new
+          puts "\t#{migration.migration_number} \t\t #{migration.name} \t\t #{m.description}"
+        end
+
+        puts "\n\n"
+      end 
+
+      # Prints in the console all migrations that has been ran at least once with their name and description  
+      def db_status
+        puts "\n Migration n#:  \t   Name: \t\t     Direction:     Arguments:      Current Status: \t Last completion Date: \t\t Current Message:"
+        puts '-' * 175, "\n"
+
+        Migration.all.each do|migration|
+          puts "\t#{migration.class.migration_number} \t #{migration.class.name} \t #{migration.status.to_string}"
+        end
+
+        puts "\n\n"
+      end 
+    end
+
+    # Makes sure status get instanciated on migration's instanciation
+    def initialize(args = {})
+      self.build_status(args[:status])
+      super(args)
+    end
+
+    # Runs the migration following the direction
+    # sets the status, the execution time and the last succesful_completion date
+    def run(direction)
+      self.status.direction = direction
+
+      # reset the status if the job is rerunnable and has already be completed
+      self.status = self.status.reset if self.rerunnable_safe && completed?(direction) 
+      self.status.execution_time = time_it { self.send(direction) }
+      self.status.last_succesful_completion = Time.now
+    end
+
+    # Sets an error to migration status 
+    def failure=(exception)
+      self.status.error = MigrationError.new(:error_message => exception.message, :error_class => exception.class, :error_backtrace => exception.backtrace)
+    end
+
+    # Checks if a migration can be run
+    def is_runnable?(direction)
+      rerunnable_safe || (direction == UP && status.current_status < status_complete) || (direction == DOWN && status.current_status > 0)
+    end
+
+    # Checks if a migration as been completed
+    def completed?(direction) 
+      return false if self.status.execution_time == 0
+      (direction == UP && self.status.current_status == self.status_complete) || (direction == DOWN && self.status.current_status == 0)
+    end
+
+    protected
+
+    # Executes a given block if the status has not being processed
+    # Then update the status
+    def step(step_message = nil, step_status = 1)
+      unless status.status_processed?(status.direction, step_status)
+        self.status.message = step_message
+        puts "\t #{step_message}" 
+
+        yield if block_given?
+        self.status.current_status += status.direction_to_i
+      end
+    end
+
+    # Prints a given message with the current time 
+    def tick(msg)
+      puts "#{Time.now}: #{msg}"
+    end
+
+    # Executes a block and returns the time it took to be executed
+    def time_it
+      puts "Running #{self.class}[#{self.status.arguments}](#{self.status.direction})"
+
+      start = Time.now
+      yield if block_given?
+      end_time = Time.now - start
+      
+      puts "Tasks #{self.class} executed in #{end_time} seconds. \n\n"
+      end_time
+    end
+
+    # contains the code that will be executed when run(up) will be called
+    def up
+      raise StandardError, 'Needs to be implemented in child class.'
+    end
+
+    # contains the code that will be executed when run(down) will be called
+    def down
+      raise StandardError, 'Needs to be implemented in child class.'
+    end
+  end
+end
+
+Dir[File.dirname(__FILE__) + "/*.rb"].sort.each { |file|  require file;}

data/lib/exodus/migrations/migration_error.rb

@@ -0,0 +1,11 @@
+module Exodus
+	class MigrationError
+		include MongoMapper::EmbeddedDocument
+		
+	  key :error_message,               String
+	  key :error_class,                 String
+	  key :error_backtrace,             Array
+
+	  embedded_in :migration_status
+	end
+end

data/lib/exodus/migrations/migration_status.rb

@@ -0,0 +1,39 @@
+module Exodus
+  class MigrationStatus
+    include MongoMapper::EmbeddedDocument
+
+    key :message,                     String
+    key :current_status,  						Integer, :default => 0
+    key :execution_time,              Float, :default => 0
+    key :last_succesful_completion,   Time
+    key :direction,                   String, :default => Migration::UP
+    key :arguments, 									Hash, :default => {}
+
+    embedded_in :migration
+    has_one :error, :class_name => "Exodus::MigrationError", :autosave => true
+
+    def direction_to_i
+      self.direction == Migration::UP ? 1 : -1
+    end
+
+    # Checks if a status has been processed
+    # a Status has been processed when:
+    # The current status is superior or equal to the given status and the migration direction is UP
+    # The current status is inferior or equal to the given status and the migration direction is DOWN
+    def status_processed?(migration_direction, status_to_process)
+    	(migration_direction == Migration::UP && current_status >= status_to_process) || (migration_direction == Migration::DOWN && current_status <= status_to_process)
+    end
+
+    def to_string
+      "\t#{direction}\t\t #{arguments}\t\t #{current_status} \t\t #{last_succesful_completion} \t\t #{message}"
+    end
+
+    # Resets a status
+    def reset
+      self.message = nil
+      self.current_status = 0
+      self.execution_time = 0
+      self.last_succesful_completion = nil
+    end
+  end
+end

data/lib/exodus/version.rb

@@ -1,3 +1,3 @@
 module Exodus
-  VERSION = "1.0.0"
+  VERSION = "1.0.1"
 end

data/spec/exodus/migration_spec.rb

@@ -0,0 +1,187 @@
+require "spec_helper"
+require File.dirname(__FILE__) + "/../../lib/exodus"
+
+describe Exodus::Migration do
+
+  describe "New Oject" do
+    subject { Exodus::Migration.new }
+
+    it "should have a status" do
+      subject.status.should_not be_nil
+    end
+
+    it "should have default value for [status_complete, rerunnable_safe]" do
+      subject.status_complete.should == 1
+      subject.rerunnable_safe.should be_false
+    end
+  end
+
+  describe "class methods" do
+    subject { Exodus::Migration.new }
+
+    describe "#inherited" do
+      it "should add a new migrations when a new migration class is created" do
+        migration_size = subject.class.load_all([]).size.to_i
+        class Migration_test1 < Exodus::Migration; end
+
+        subject.class.load_all([]).size.should == migration_size + 1
+      end
+    end
+
+    describe "#load_all" do
+      it "should override migrations" do
+        first_migration = subject.class.load_all([]).first.first 
+        subject.class.load_all([[first_migration, {:test_args => ['some', 'test', 'arguments']}]]).should include [first_migration, {:test_args => ['some', 'test', 'arguments']}] 
+      end
+
+      it "should add a new migrations if the migration is not present" do
+        migration_classes = subject.class.load_all([]).map{|migration, args| migration}
+        class CompleteNewMigration < Exodus::Migration; end
+        
+        reloaded_migration_classes = subject.class.load_all([[CompleteNewMigration.name]]).map{|migration, args| migration} 
+        reloaded_migration_classes.should include CompleteNewMigration 
+      end
+    end
+  end
+
+  describe "instance methods" do
+    before do
+      class Migration_test1 < Exodus::Migration
+        def up 
+          step("Creating new APIUser entity", 1) {UserSupport.create(:name =>'testor')}
+        end
+
+        def down 
+          step("Droping APIUser entity", 0) do 
+            user = UserSupport.first
+            user.destroy if user
+          end
+        end
+      end
+    end
+
+    subject { Migration_test1.first_or_create({}) }
+
+    describe "#run" do
+      it "should create a new APIUser when running it up" do
+        Migration_test1.collection.drop
+        UserSupport.collection.drop
+
+        lambda{ subject.run('up')}.should change { UserSupport.count }.by(1)
+        subject.status.arguments.should be_empty
+        subject.status.current_status.should == 1
+        subject.status.direction.should == 'up'
+        subject.status.execution_time.should > 0
+        subject.status.last_succesful_completion.should
+        subject.status.message.should == 'Creating new APIUser entity'
+      end
+
+      it "should delete an APIUser when running it down" do
+        Migration_test1.collection.drop
+        UserSupport.collection.drop
+        subject.run('up')
+
+        lambda{ subject.run('down')}.should change { UserSupport.count }.by(-1)
+        subject.status.arguments.should be_empty
+        subject.status.current_status.should == 0
+        subject.status.direction.should == 'down'
+        subject.status.execution_time.should > 0
+        subject.status.message.should == 'Droping APIUser entity'
+      end
+    end
+
+    describe "#failure=" do
+      it "should save error information" do
+        exception = nil
+
+        begin
+          raise StandardError "This is an error"
+        rescue Exception  => e
+          subject.failure = e
+          exception = e
+        end
+
+        subject.status.error.error_message.should == exception.message
+        subject.status.error.error_class.should == exception.class.name
+        subject.status.error.error_backtrace.should == exception.backtrace
+      end
+    end
+
+    describe "#time_it" do
+      it "should execute a block and set the execution_time" do
+        Migration_test1.collection.drop
+        UserSupport.collection.drop
+
+        lambda do 
+          time = subject.send(:time_it) {UserSupport.create(:name => 'testor')}
+        end.should change { UserSupport.count }.by(1)
+      end
+    end
+
+    describe "#completed?" do
+      it "should be false when the job is not completed" do
+        Migration_test1.collection.drop
+        UserSupport.collection.drop
+
+        subject.completed?('up').should be_false
+        subject.completed?('down').should be_false
+      end
+
+      it "should be completed up when the job has ran up" do
+        subject.run('up')
+
+        subject.completed?('up').should be_true
+        subject.completed?('down').should be_false
+      end
+
+      it "should be completed down when the job has ran down" do
+        subject.run('down')
+
+        subject.completed?('up').should be_false
+        subject.completed?('down').should be_true
+      end
+    end
+
+    describe "#is_runnable?" do
+      it "should only be runable up when it has never run before" do
+        Migration_test1.collection.drop
+        UserSupport.collection.drop
+
+        subject.is_runnable?('up').should be_true
+        subject.is_runnable?('down').should be_false
+      end
+
+      it "should not be runable up when it has ran up before" do
+        subject.run('up')
+
+        subject.is_runnable?('up').should be_false
+        subject.is_runnable?('down').should be_true
+      end
+
+      it "should not be runable down when it has ran down before" do
+        subject.run('down')
+
+        subject.is_runnable?('up').should be_true 
+        subject.is_runnable?('down').should be_false
+      end
+
+      it "should be runable when if the task is safe" do
+        subject.rerunnable_safe = true
+
+        subject.is_runnable?('up').should be_true 
+        subject.is_runnable?('down').should be_true
+      end
+    end
+  end
+
+  describe "MigrationFramework" do 
+    describe "sort_migrations" do 
+      it "should return the migrations sorted by migration number" do 
+        CompleteNewMigration.migration_number = 10
+        sorted_migrations = Exodus::sort_migrations(Exodus::Migration.load_all([]))
+        migrations_number = sorted_migrations.map {|migration, args| migration.migration_number }
+        migrations_number.should == migrations_number.sort          
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,10 @@
+require File.dirname(__FILE__) + '/../lib/exodus'
+Dir["#{File.dirname(__FILE__)}/support/*.rb"].each { |f| require f }
+mongo_uri = 'mongodb://exodus:exodus@dharma.mongohq.com:10048/Exodus-test'
+
+Exodus.configure do |config| 
+	config.db = 'Exodus-test'
+	config.connection = Mongo::MongoClient.from_uri(mongo_uri)
+	config.config_file = File.dirname(__FILE__) + '/support/config.yml'
+end
+

data/spec/support/config.yml

@@ -0,0 +1,6 @@
+migration:
+  migrate:
+  rollback:
+  custom:
+    migrate:
+    rollback: 

data/spec/support/user_support.rb

@@ -0,0 +1,4 @@
+class UserSupport
+	include MongoMapper::Document
+	key :name, String
+end

data/tasks/exodus.rake

@@ -0,0 +1,78 @@
+def time_it(task, &block)
+  puts "#{task} starting..."
+  start = Time.now
+  yield
+  puts "#{task} Done in (#{Time.now-start}s)!!"
+end
+
+def step
+  ENV['STEP']
+end
+
+task :require_env do
+  require 'csv'
+  require File.dirname(__FILE__) + '/../lib/exodus'
+end
+
+namespace :db do
+  desc "Migrate the database"
+  task :migrate => :require_env do 
+    time_it "db:migrate#{" step #{step}" if step}" do 
+      migrations = Migration.load_all(Exodus.migrations_info.migrate)
+      Exodus::run_migrations('up', migrations, step)
+    end
+  end
+
+  desc "Rolls the database back to the previous version"
+  task :rollback => :require_env do 
+    time_it "db:rollback#{" step #{step}" if step}" do 
+      migrations = Migration.load_all(Exodus.migrations_info.rollback)
+      Exodus::run_migrations('down', migrations, step)
+    end
+  end
+
+  namespace :migrate do
+    desc "Manually migrates specified migrations (specify migrations or use config/migration.yml)"
+    task :custom, [:migrations_info] => :require_env do |t, args|
+      time_it "db:migrate_custom#{" step #{step}" if step}" do 
+         migrations = if args[:migrations_info]
+          YAML.load(args[:migrations_info])
+        else
+          Migration.load_custom(Exodus.migrations_info.migrate_custom)
+        end
+
+        Exodus::run_migrations('up', migrations, step)
+      end
+    end
+
+    desc "Lists all the migrations"
+    task :list => :require_env do 
+      Migration.list
+    end
+
+    desc "Loads migration.yml and displays it"
+    task :yml_status => :require_env do 
+      pp Exodus.migrations_info.to_s
+    end
+
+    desc "Displays the current status of migrations"
+    task :status => :require_env do 
+      Migration.db_status
+    end
+  end
+
+  namespace :rollback do
+    desc "Manually rolls the database back using specified migrations (specify migrations or use config/migration.yml)"
+    task :custom, [:migrations_info] => :require_env do |t, args|
+      time_it "db:rollback_custom#{" step #{step}" if step}" do 
+         migrations = if args[:migrations_info]
+          YAML.load(args[:migrations_info])
+        else
+          Migration.load_custom(Exodus.migrations_info.rollback_custom)
+        end
+
+        Exodus::run_migrations('down', migrations, step)
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: exodus
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-27 00:00:00.000000000 Z
+date: 2013-05-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mongo_mapper
@@ -75,7 +75,7 @@ dependencies:
     - - ! '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Exodus is a migration framework for Mongo
+description: Exodus is a migration framework for MongoDb
 email:
 - thomas@fanhattan.com
 - thomas.dmytryk@supinfo.com
@@ -84,13 +84,26 @@ extensions: []
 extra_rdoc_files: []
 files:
 - .gitignore
+- .rspec
+- .rvmrc
+- .travis.yml
+- CHANGELOG.md
 - Gemfile
 - LICENSE
 - README.md
 - Rakefile
 - exodus.gemspec
 - lib/exodus.rb
+- lib/exodus/config/migration_info.rb
+- lib/exodus/migrations/migration.rb
+- lib/exodus/migrations/migration_error.rb
+- lib/exodus/migrations/migration_status.rb
 - lib/exodus/version.rb
+- spec/exodus/migration_spec.rb
+- spec/spec_helper.rb
+- spec/support/config.yml
+- spec/support/user_support.rb
+- tasks/exodus.rake
 homepage: ''
 licenses:
 - MIT
@@ -116,4 +129,8 @@ rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Exodus uses mongomapper to provide a complete migration framework
-test_files: []
+test_files:
+- spec/exodus/migration_spec.rb
+- spec/spec_helper.rb
+- spec/support/config.yml
+- spec/support/user_support.rb